teradata-cli 0.0.1

data/lib/teradata/exception.rb

@@ -0,0 +1,15 @@
+#
+# $Id: exception.rb 7 2010-03-04 16:54:09Z tdaoki $
+#
+# Copyright (C) 2009,2010 Teradata Japan, LTD.
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL2, Lesser General Public License version 2.
+#
+
+module Teradata
+
+  class Error < StandardError; end
+
+end

data/lib/teradata/utils.rb

@@ -0,0 +1,184 @@
+#
+# $Id: utils.rb 7 2010-03-04 16:54:09Z tdaoki $
+#
+# Copyright (C) 2009,2010 Teradata Japan, LTD.
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL2, Lesser General Public License version 2.
+#
+
+require 'teradata/exception'
+
+module Teradata
+
+  class BadLogonString < Error; end
+
+  class LogonString
+    def LogonString.intern(arg)
+      arg.kind_of?(LogonString) ? arg : LogonString.parse(arg.to_s)
+    end
+
+    def LogonString.parse(str)
+      m = %r<\A(?:([^/\s]+)/)?(\w+),(\w+)(?:,('.*'))?\z>.match(str) or
+          raise BadLogonString, "bad logon string: #{str.inspect}"
+      new(* m.captures)
+    end
+
+    def initialize(tdpid, user, password, account = nil)
+      @tdpid = tdpid
+      @user = user
+      @password = password
+      @account = account
+    end
+
+    attr_reader :tdpid
+    attr_reader :user
+    attr_reader :password
+    attr_reader :account
+
+    def to_s
+      "#{@tdpid ? @tdpid + '/' : ''}#{@user},#{@password}#{@account ? ',' + @account : ''}"
+    end
+
+    def safe_string
+      "#{@tdpid ? @tdpid + '/' : ''}#{@user},****#{@account ? ',' + @account : ''}"
+    end
+
+    def inspect
+      "\#<#{self.class} #{to_s}>"
+    end
+  end
+
+  class SessionCharset
+    def SessionCharset.intern(arg)
+      arg.kind_of?(SessionCharset) ? arg : SessionCharset.new(arg.to_s)
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    attr_reader :name
+    alias to_s name
+
+    if defined?(::Encoding)   # M17N
+      def encoding
+        case @name
+        when /UTF8/i then Encoding::UTF_8
+        when /KANJISJIS_0S/i then Encoding::Windows_31J
+        when /KANJIEUC_0U/i then Encoding::EUC_JP
+        when /ASCII/i then Encoding::US_ASCII
+        else
+          raise ArgumentError, "could not convert session charset to encoding name: #{sc.inspect}"
+        end
+      end
+    else
+      def encoding
+        nil
+      end
+    end
+  end
+
+  module MetadataUtils
+    def adjust_list_size(list, size)
+      if list.size > size
+        list[0...size]
+      else
+        list.push nil while list.size < size
+        list
+      end
+    end
+  end
+
+  SESSION_ATTRIBUTES = [
+    :user_name,
+    :account_name,
+    :logon_date,
+    :logon_time,
+    :current_database,
+    :collation,
+    :character_set,
+    :transaction_semantics,
+    :current_dateform,
+    :timezone,
+    :default_character_type,
+    :export_latin,
+    :export_unicode,
+    :export_unicode_adjust,
+    :export_kanjisjis,
+    :export_graphic,
+    :default_date_format,
+    :radix_separator,
+    :group_separator,
+    :grouping_rule,
+    :currency_radix_separator,
+    :currency_graphic_rule,
+    :currency_grouping_rule,
+    :currency_name,
+    :currency,
+    :iso_currency,
+    :dual_currency_name,
+    :dual_currency,
+    :dual_iso_currency,
+    :default_byteint_format,
+    :default_integer_format,
+    :default_smallint_format,
+    :default_numeric_format,
+    :default_real_format,
+    :default_time_format,
+    :default_timestamp_format,
+    :current_role,
+    :logon_account,
+    :profile,
+    :ldap,
+    :audit_trail_id,
+    :current_isolation_level,
+    :default_bigint_format,
+    :query_band
+  ]
+
+  SessionInfo = Struct.new(*SESSION_ATTRIBUTES)
+
+  class SessionInfo   # reopen
+    extend MetadataUtils
+
+    def SessionInfo.for_record(rec)
+      new(* adjust_list_size(rec.to_a, SESSION_ATTRIBUTES.size))
+    end
+  end
+
+  module SQLUtils
+    private
+
+    def sql_int(n)
+      return 'NULL' unless n
+      n
+    end
+
+    alias int sql_int
+
+    def sql_string(str)
+      return 'NULL' unless str
+      "'" + str.gsub(/'/, "''") + "'"
+    end
+
+    alias string sql_string
+
+    def sql_date(d)
+      return 'NULL' unless d
+      "DATE '#{d.strftime('%Y-%m-%d')}'"
+    end
+
+    alias date sql_date
+
+    def sql_timestamp(t)
+      return 'NULL' unless t
+      "TIMESTAMP '#{t.strftime('%Y-%m-%d %H:%M:%S')}'"
+    end
+
+    alias timestamp sql_timestamp
+  end
+
+
+end

data/teradata-cli.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'teradata/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "teradata-cli"
+  spec.version       = Teradata::Cli::VERSION
+  spec.authors       = ["Giuseppe Privitera"]
+  spec.email         = ["priviterag@gmail.com"]
+  spec.description   = %q{ruby extension for Teradata Cliv2}
+  spec.summary       = %q{ruby extension for Teradata Cliv2}
+  spec.homepage      = "https://github.com/priviterag/teradata-cli"
+  spec.license       = "LGPL2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions    = ["ext/teradata/cli/extconf.rb"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/test/all

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+basedir = File.dirname($0)
+$LOAD_PATH.unshift basedir
+Dir.glob("#{basedir}/test_*.rb") do |test_case|
+  load test_case
+end

data/test/rubyclitestutils.rb

@@ -0,0 +1,99 @@
+module RubyCLITestUtils
+
+  def logon_string
+    s = ENV['TEST_LOGON_STRING'] or raise ArgumentError, "environ TEST_LOGON_STRING not given"
+    Teradata::LogonString.parse(s)
+  end
+
+  def playpen_string
+    s = ENV['TEST_PLAYPEN_STRING']
+    s == '' ? nil : "#{s}"
+  end
+
+  def env_string
+    s = ENV['TEST_ENV_STRING']
+    s == '' ? nil : "#{s}"
+  end
+
+  def get_table_name(name)
+    "#{playpen_string ? playpen_string + '.' : ''}#{env_string ? env_string + '_' : ''}#{name}"
+  end
+
+  def connect(*args)
+    options = {}
+    unless args.empty?
+      charset, internal = args
+      options[:session_charset] = charset if charset
+      options[:internal_encoding] = internal if internal
+    end
+    Teradata::Connection.open(logon_string, options) {|conn|
+      begin
+        @conn = conn
+        yield conn
+      ensure
+        @conn = nil
+      end
+    }
+  end
+
+  def using_test_table(name = "#{get_table_name('t')}", conn = @conn, &block)
+    unless conn
+      connect {|_conn| using_test_table(name, _conn, &block) }
+      return
+    end
+    using_table(name, 'x INTEGER, y INTEGER', conn) do |n|
+      %w(1,2 3,4 5,6).each do |values|
+        insert n, values, conn
+      end
+      yield n
+    end
+  end
+
+  def using_table(name, fields, conn = @conn, &block)
+    unless conn
+      connect {|_conn| using_table(name, fields, _conn, &block) }
+      return
+    end
+    drop_table_force name, conn
+    conn.execute_update "CREATE TABLE #{name} (#{fields});"
+    begin
+      yield name
+    ensure
+      drop_table_force name, conn
+    end
+  end
+
+  def create_table(name, fields, conn = @conn)
+    conn.execute_update "CREATE TABLE #{name} (#{fields});"
+  end
+
+  ERR_OBJECT_NOT_EXIST = 3807
+  ERR_INDEX_NOT_EXIST = 3526
+
+  def drop_table_force(name, conn = @conn)
+    drop_table name, conn
+  rescue Teradata::SQLError => err
+    raise err unless err.code == ERR_OBJECT_NOT_EXIST
+  end
+
+  def drop_table(name, conn = @conn)
+    drop 'TABLE', name, conn
+  end
+
+  def drop(type, name, conn = @conn)
+    conn.execute_update "DROP #{type} #{name};"
+  end
+
+  def delete(table, conn = @conn)
+    conn.execute_update "DELETE FROM #{table};"
+  end
+
+  def insert(table, values, conn = @conn)
+    conn.execute_update "INSERT INTO #{table} (#{values});"
+  end
+
+  def select(table, conn = @conn)
+    conn.entries "SELECT * FROM #{table} ORDER BY 1;"
+  end
+
+end

data/test/test_connection.rb

@@ -0,0 +1,298 @@
+require 'teradata'
+require 'test/unit'
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+require 'rubyclitestutils'
+
+class Test_Connection < Test::Unit::TestCase
+
+  include RubyCLITestUtils
+
+  def test_s_open
+    begin
+      conn = Teradata::Connection.open(logon_string)
+      assert_instance_of Teradata::Connection, conn
+      assert_equal false, conn.closed?
+    ensure
+      begin
+        conn.close
+      rescue
+      end
+      assert_equal true, conn.closed?
+    end
+
+    Teradata::Connection.open(logon_string) {|c| assert_instance_of(Teradata::Connection, c); assert_equal(false, c.closed?)}
+    assert_equal true, conn.closed?
+  end
+
+  def test_execute_update
+    connect {
+      drop_table_force "#{get_table_name('t')}"
+      x = @conn.execute_update("CREATE TABLE #{get_table_name('t')} (x INTEGER);")
+      assert_instance_of Teradata::ResultSet, x
+      assert_equal true, x.closed?
+    }
+  end
+
+  def test_txn
+    using_table("#{get_table_name('t')}", "x INTEGER, y INTEGER") {|name|
+      @conn.execute_update "BEGIN TRANSACTION;"
+      @conn.execute_update "INSERT INTO #{name} (x,y) VALUES (1,2);"
+      @conn.execute_update "INSERT INTO #{name} (x,y) VALUES (3,4);"
+      @conn.execute_update "END TRANSACTION;"
+      recs = @conn.entries("SELECT * FROM #{name} ORDER BY 1;")
+      assert_equal 2, recs.size
+
+      begin
+        @conn.execute_update "BEGIN TRANSACTION;"
+        @conn.execute_update "DELETE FROM #{name};"
+        @conn.execute_update "ABORT;"
+      rescue Teradata::UserAbort
+      end
+      recs = @conn.entries("SELECT * FROM #{name} ORDER BY 1;")
+      assert_equal 2, recs.size
+      assert_equal 1, recs[0][:x]
+    }
+  end
+
+  def test_execute_query
+    using_test_table {|name|
+      _test_single_rs name, @conn
+      _test_single_rs2 name, @conn
+      _test_multiple_rs name, @conn
+    }
+  end
+
+  def _test_single_rs(name, conn)
+    buf = []
+    conn.execute_query("SELECT * FROM #{name} ORDER BY 1") {|rs|
+      assert_instance_of Teradata::ResultSet, rs
+      rs.each do |rec|
+        buf.push rec
+      end
+    }
+    assert_equal 3, buf.size
+    assert_instance_of Teradata::Record, buf[0]
+    assert_equal 1, buf[0][:x]
+    assert_equal 2, buf[0][:y]
+    assert_instance_of Teradata::Record, buf[1]
+    assert_equal 3, buf[1][:x]
+    assert_equal 4, buf[1][:y]
+    assert_instance_of Teradata::Record, buf[2]
+    assert_equal 5, buf[2][:x]
+    assert_equal 6, buf[2][:y]
+  end
+
+  def _test_single_rs2(name, conn)
+    buf = []
+    num_rs = 0
+    conn.execute_query("SELECT * FROM #{name} ORDER BY 1") {|sets|
+      assert_instance_of Teradata::ResultSet, sets
+      sets.each_result_set do |rs|
+        num_rs += 1
+        assert_instance_of Teradata::ResultSet, rs
+        rs.each do |rec|
+          buf.push rec
+        end
+      end
+    }
+    assert_equal 1, num_rs
+    assert_equal 3, buf.size
+    buf.each do |r|
+      assert_instance_of Teradata::Record, r
+    end
+    assert_equal [1,2], [buf[0][:x], buf[0][:y]]
+    assert_equal [3,4], [buf[1][:x], buf[1][:y]]
+    assert_equal [5,6], [buf[2][:x], buf[2][:y]]
+  end
+
+  def _test_multiple_rs(name, conn)
+    buf = []
+    num_rs = 0
+    conn.execute_query(
+      "SELECT * FROM #{name} ORDER BY 1;
+         SELECT * FROM #{name} ORDER BY 1 DESC;") {|sets|
+      assert_instance_of Teradata::ResultSet, sets
+      sets.each_result_set do |rs|
+        num_rs += 1
+        assert_instance_of Teradata::ResultSet, rs
+        rs.each do |rec|
+          buf.push rec
+        end
+      end
+    }
+    assert_equal 2, num_rs
+    assert_equal 6, buf.size
+    buf.each do |r|
+      assert_instance_of Teradata::Record, r
+    end
+    assert_equal [1,2], [buf[0][:x], buf[0][:y]]
+    assert_equal [3,4], [buf[1][:x], buf[1][:y]]
+    assert_equal [5,6], [buf[2][:x], buf[2][:y]]
+    assert_equal [5,6], [buf[3][:x], buf[3][:y]]
+    assert_equal [3,4], [buf[4][:x], buf[4][:y]]
+    assert_equal [1,2], [buf[5][:x], buf[5][:y]]
+  end
+
+  def test_execute_query_without_block
+    using_test_table {|name|
+      rs = @conn.execute_query("SELECT * FROM #{get_table_name('t')} ORDER BY 1;")
+
+      recs = []
+      rs.each do |rec|
+        recs.push rec
+      end
+      assert_equal 3, recs.size
+      assert_equal 1, recs[0][:x]
+      assert_equal 6, recs[2][:y]
+
+      recs = rs.entries
+      assert_equal 3, recs.size
+      assert_equal 1, recs[0][:x]
+      assert_equal 6, recs[2][:y]
+    }
+  end
+
+  def test_entries
+    using_test_table {|name|
+      recs = @conn.entries("SELECT * FROM #{name} ORDER BY 1;")
+      assert_equal 3, recs.size
+      assert_equal 1, recs[0][:x]
+      assert_equal 6, recs[2][:y]
+    }
+  end
+
+  # Teradata hates "\n", check it.
+  def test_line_terms
+    using_test_table {|name|
+      recs = @conn.entries("SELECT *\nFROM #{name} \n ORDER BY 1;")
+      assert_equal 3, recs.size
+
+      assert_nothing_thrown {
+        @conn.execute_update "INSERT INTO #{name}\n(x,y)\nVALUES \n (7,8);"
+      }
+      recs = @conn.entries("SELECT *\nFROM #{name} \n ORDER BY 1;")
+      assert_equal 4, recs.size
+    }
+  end
+
+  # connection/request intersection test
+  def test_duplicated_connections
+    assert_nothing_thrown {
+      connect {|c1|
+      connect {|c2|
+        drop_table_force "#{get_table_name('t')}", c1
+        c2.execute_update "CREATE TABLE #{get_table_name('t')} (x INTEGER);"
+        drop_table_force "#{get_table_name('t')}", c1
+        c2.execute_update "CREATE TABLE #{get_table_name('t')} (x INTEGER);"
+        drop_table_force "#{get_table_name('t')}", c1
+      }
+    }
+    }
+  end
+
+  def test_tables
+    db = playpen_string
+    connect {|conn|
+      # assert_equal [], @conn.tables(db)
+      using_test_table(get_table_name('t1')) {
+        using_test_table(get_table_name('t2')) {
+        list = @conn.tables(db)
+        assert(list.include? Teradata::Table.new(db, 't1'))
+        assert(list.include? Teradata::Table.new(db, 't2'))
+      }}
+    }
+  end
+
+  def test_views
+    db = playpen_string
+    using_test_table do
+      using_view("#{get_table_name('v')}", 'select 1 as i') do
+        assert(@conn.views(db).include? Teradata::View.new(db, 'v'))
+      end
+    end
+  end
+
+  def test_objects
+    db = playpen_string
+    connect do
+      # assert_equal [], @conn.objects(db)
+      using_test_table(get_table_name('t')) do
+        using_view("#{get_table_name('v')}", 'select 1 as i') do
+          objects = @conn.objects(db)
+          assert(objects.include? Teradata::Table.new(db, 't'))
+          assert(objects.include? Teradata::View.new(db, 'v'))
+        end
+      end
+    end
+  end
+
+  def using_view(name, query, conn = @conn)
+    drop_view_force name, conn
+    begin
+      conn.execute_update "CREATE VIEW #{name} AS #{query}"
+      yield name
+    ensure
+      drop_view_force name, conn
+    end
+  end
+
+  def drop_view_force(name, conn = @conn)
+    conn.execute_update "DROP VIEW #{name}"
+  rescue Teradata::SQLError
+  end
+
+  def test_info
+    connect {
+      info = @conn.info
+      assert_instance_of Teradata::SessionInfo, info
+      assert_equal logon_string.user.downcase, info.user_name.downcase
+    }
+  end
+
+  def test_column
+    db = playpen_string
+    using_table("#{get_table_name('t')}", "x INTEGER, y INTEGER") do
+      col = @conn.column(Teradata::Table.new(db, 't'), 'x')
+      assert_instance_of Teradata::Column, col
+      assert_equal 'x', col.column_name.strip.downcase
+    end
+  end
+
+  def test_transaction
+    connect {|conn|
+      using_test_table("#{get_table_name('t')}") {|table|
+        n_records = count(table, conn)
+
+        # transaction fails #1
+        assert_raise(RuntimeError) {
+          conn.transaction {
+          conn.query "DELETE FROM #{table}"
+          raise RuntimeError, "USER ABORT"
+        }
+        }
+        assert_equal n_records, count(table, conn)
+
+        # transaction fails #2
+        assert_raise(Teradata::UserAbort) {
+          conn.transaction {
+          conn.query "DELETE FROM #{table}"
+          conn.abort
+        }
+        }
+        assert_equal n_records, count(table, conn)
+
+        # transaction success
+        conn.transaction {
+          conn.query "DELETE FROM #{table}"
+        }
+        assert_equal 0, count(table, conn)
+      }
+    }
+  end
+
+  def count(table, conn)
+    conn.entries("SELECT count(*) FROM #{table}").first[0]
+  end
+
+end