class OCI8

def self.client_charset_name
  @@client_charset_name
end

def self.oracle_client_version
  @@oracle_client_version
end

def self.properties
  @@properties
end

def database_charset_name
  charset_id2name(@server_handle.send(:attr_get_ub2, OCI_ATTR_CHARSET_ID))
end

def describe_any(object_name)
  if /^PUBLIC\.(.*)/i =~ object_name
    md = __describe($1, OCI8::Metadata::Unknown, true)
    raise OCIError.new(4043, object_name) if md.obj_schema != 'PUBLIC'
    md
  else
    __describe(object_name, OCI8::Metadata::Unknown, true)
  end
end

def describe_database(database_name)
  __describe(database_name, OCI8::Metadata::Database, false)
end

def describe_function(function_name)
  __describe(function_name, OCI8::Metadata::Function, false)
end

def describe_package(package_name)
  __describe(package_name, OCI8::Metadata::Package, false)
end

def describe_procedure(procedure_name)
  __describe(procedure_name, OCI8::Metadata::Procedure, false)
end

def describe_schema(schema_name)
  __describe(schema_name, OCI8::Metadata::Schema, false)
end

def describe_sequence(sequence_name)
  __describe(sequence_name, OCI8::Metadata::Sequence, false)
end

def describe_synonym(synonym_name, check_public_also = true)
  if /^PUBLIC\.(.*)/i =~ synonym_name
    md = __describe($1, OCI8::Metadata::Synonym, true)
    raise OCIError.new(4043, synonym_name) if md.obj_schema != 'PUBLIC'
    md
  else
    __describe(synonym_name, OCI8::Metadata::Synonym, check_public_also)
  end
end

def describe_table(table_name, table_only = false)
  if table_only
    # check my own tables only.
    __describe(table_name, OCI8::Metadata::Table, false)
  else
    # check tables, views, synonyms and public synonyms.
    # follow synonyms up to 20 times to prevent infinite loop
    # caused by recursive synonyms.
    recursive_level = 20
    recursive_level.times do
      metadata = __describe(table_name, OCI8::Metadata::Unknown, true)
      case metadata
      when OCI8::Metadata::Table, OCI8::Metadata::View
        return metadata
      when OCI8::Metadata::Synonym
        table_name = metadata.translated_name
        if metadata.obj_link and metadata.link.nil?
          # table_name is a synonym in a remote database for an object in the
          # remote database itself.
          table_name = "#{table_name}@#{metadata.obj_link}"
        end
      else
        raise OCIError.new(4043, table_name) # ORA-04043: object %s does not exist
      end
    end
    raise OCIError.new(36, recursive_level) # ORA-00036: maximum number of recursive SQL levels (%s) exceeded
  end
end

def describe_type(type_name)
  __describe(type_name, OCI8::Metadata::Type, false)
end

def describe_view(view_name)
  __describe(view_name, OCI8::Metadata::View, false)
end

def exec(sql, *bindvars, &block)
  @last_error = nil
  exec_internal(sql, *bindvars, &block)
end

def exec_internal(sql, *bindvars)
  begin
    cursor = parse(sql)
    ret = cursor.exec(*bindvars)
    case cursor.type
    when :select_stmt
      if block_given?
        cursor.fetch { |row| yield(row) }   # for each row
        ret = cursor.row_count()
      else
        ret = cursor
        cursor = nil # unset cursor to skip cursor.close in ensure block
        ret
      end
    when :begin_stmt, :declare_stmt # PL/SQL block
      if block_given?
        ary = []
        cursor.keys.sort.each do |key|
          ary << cursor[key]
        end
        yield(*ary)
      else
        ret
      end
    else
      ret # number of rows processed
    end
  ensure
    cursor.nil? || cursor.close
  end
end # exec

def get_tdo_by_class(klass)
  @id_to_tdo ||= {}
  @name_to_tdo ||= {}
  tdo = @name_to_tdo[klass.typename]
  return tdo if tdo # found in the cache.
  metadata = describe_any(klass.typename)
  if metadata.is_a? OCI8::Metadata::Synonym
    metadata = describe_any(metadata.translated_name)
  end
  unless metadata.is_a? OCI8::Metadata::Type
    raise "unknown typename #{klass.typename}"
  end
  OCI8::TDO.new(self, metadata, klass)
end

def get_tdo_by_metadata(metadata)
  @id_to_tdo ||= {}
  @name_to_tdo ||= {}
  tdo = @id_to_tdo[metadata.tdo_id]
  return tdo if tdo
  schema_name = metadata.schema_name
  name = metadata.name
  full_name = schema_name + '.' + name
  klass = OCI8::Object::Base.get_class_by_typename(full_name)
  klass = OCI8::Object::Base.get_class_by_typename(name) if klass.nil?
  if klass.nil?
    if schema_name == username
      eval <<EOS
dule Object
class #{name.downcase.gsub(/(^|_)(.)/) { $2.upcase }} < OCI8::Object::Base
  set_typename('#{name}')
end
d
S
      klass = OCI8::Object::Base.get_class_by_typename(name)
    else
      eval <<EOS
dule Object
module #{schema_name.downcase.gsub(/(^|_)(.)/) { $2.upcase }}
  class #{name.downcase.gsub(/(^|_)(.)/) { $2.upcase }} < OCI8::Object::Base
    set_typename('#{full_name}')
  end
end
d
S
      klass = OCI8::Object::Base.get_class_by_typename(full_name)
    end
  end
  OCI8::TDO.new(self, metadata, klass)
end

def get_tdo_by_typename(typename)
  tdo = @name_to_tdo && @name_to_tdo[typename]
  return tdo if tdo
  metadata = describe_any(typename)
  if metadata.is_a? OCI8::Metadata::Synonym
    metadata = describe_any(metadata.translated_name)
  end
  unless metadata.is_a? OCI8::Metadata::Type
    raise "unknown typename #{typename}"
  end
  tdo = get_tdo_by_metadata(metadata)
  @name_to_tdo[typename] = tdo
  tdo
end

def initialize(*args)
  if args.length == 1
    username, password, dbname, mode = parse_connect_string(args[0])
  else
    username, password, dbname, mode = args
  end
  if username.nil? and password.nil?
    cred = OCI_CRED_EXT
  end
  case mode
  when :SYSDBA
    mode = OCI_SYSDBA
  when :SYSOPER
    mode = OCI_SYSOPER
  when :SYSASM
    if OCI8.oracle_client_version < OCI8::ORAVER_11_1
      raise "SYSASM is not supported on Oracle version #{OCI8.oracle_client_version}"
    end
    mode = OCI_SYSASM
  when nil
    # do nothing
  else
    raise "unknown privilege type #{mode}"
  end
  stmt_cache_size = OCI8.properties[:statement_cache_size]
  stmt_cache_size = nil if stmt_cache_size == 0
  attach_mode = 0
  if dbname.is_a? OCI8::ConnectionPool
    @pool = dbname # to prevent GC from freeing the connection pool.
    dbname = dbname.send(:pool_name)
    attach_mode |= 0x0200 # OCI_CPOOL and OCI_LOGON2_CPOOL
  end
  if stmt_cache_size
    # enable statement caching
    attach_mode |= 0x0004 # OCI_STMT_CACHE and OCI_LOGON2_STMTCACHE
  end
  if true
    # logon by the OCI function OCISessionBegin().
    allocate_handles()
    @session_handle.send(:attr_set_string, OCI_ATTR_USERNAME, username) if username
    @session_handle.send(:attr_set_string, OCI_ATTR_PASSWORD, password) if password
    if @@oracle_client_version >= ORAVER_11_1
      # Sets the driver name displayed in V$SESSION_CONNECT_INFO.CLIENT_DRIVER
      # if both the client and the server are Oracle 11g or upper.
      # Only the first 8 chracters "ruby-oci" are displayed when the Oracle
      # server version is lower than 12.0.1.2.
      # 424: OCI_ATTR_DRIVER_NAME
      @session_handle.send(:attr_set_string, 424, "ruby-oci8 : #{OCI8::VERSION}")
    end
    server_attach(dbname, attach_mode)
    session_begin(cred ? cred : OCI_CRED_RDBMS, mode ? mode : OCI_DEFAULT)
  else
    # logon by the OCI function OCILogon2().
    logon2(username, password, dbname, attach_mode)
  end
  if stmt_cache_size
    # set statement cache size
    attr_set_ub4(176, stmt_cache_size) # 176: OCI_ATTR_STMTCACHESIZE
  end
  @prefetch_rows = 100
  @username = nil
end

def inspect
  "#<OCI8:#{username}>"
end

def oracle_server_version
  @oracle_server_version ||= OCI8::OracleVersion.new(oracle_server_vernum)
end

def parse(sql)
  @last_error = nil
  parse_internal(sql)
end

def parse_internal(sql)
  cursor = OCI8::Cursor.new(self, sql)
  cursor.prefetch_rows = @prefetch_rows if @prefetch_rows
  cursor
end

def prefetch_rows=(num)
  @prefetch_rows = num
end

def recv_timeout
  # OCI_ATTR_RECEIVE_TIMEOUT = 436
  @server_handle.send(:attr_get_ub4, 436).to_f / 1000
end

def recv_timeout
  raise NotImplementedError, 'recv_timeout is unimplemented in this Oracle version'
end

def recv_timeout=(timeout)
  # OCI_ATTR_RECEIVE_TIMEOUT = 436
  @server_handle.send(:attr_set_ub4, 436, timeout * 1000)
end

def recv_timeout=(timeout)
  raise NotImplementedError, 'revc_timeout= is unimplemented in this Oracle version'
end

def select_one(sql, *bindvars)
  cursor = self.parse(sql)
  begin
    cursor.exec(*bindvars)
    row = cursor.fetch
  ensure
    cursor.close
  end
  return row
end

def send_timeout
  # OCI_ATTR_SEND_TIMEOUT = 435
  @server_handle.send(:attr_get_ub4, 435).to_f / 1000
end

def send_timeout
  raise NotImplementedError, 'send_timeout is unimplemented in this Oracle version'
end

def send_timeout=(timeout)
  # OCI_ATTR_SEND_TIMEOUT = 435
  @server_handle.send(:attr_set_ub4, 435, timeout * 1000)
end

def send_timeout=(timeout)
  raise NotImplementedError, 'send_timeout= is unimplemented in this Oracle version'
end

def username
  @username || begin
    exec('select user from dual') do |row|
      @username = row[0]
    end
    @username
  end
end