Class: Sequel::JDBC::Database

Inherits:
Database show all
Defined in:
lib/sequel_core/adapters/jdbc.rb

Overview

JDBC Databases offer a fairly uniform interface that does not change much based on the sub adapter.

Constant Summary

Constants inherited from Database

Database::ADAPTERS, Database::SQL_BEGIN, Database::SQL_COMMIT, Database::SQL_ROLLBACK

Constants included from Schema::SQL

Schema::SQL::AUTOINCREMENT, Schema::SQL::CASCADE, Schema::SQL::COMMA_SEPARATOR, Schema::SQL::NOT_NULL, Schema::SQL::NO_ACTION, Schema::SQL::NULL, Schema::SQL::PRIMARY_KEY, Schema::SQL::RESTRICT, Schema::SQL::SET_DEFAULT, Schema::SQL::SET_NULL, Schema::SQL::TYPES, Schema::SQL::UNDERSCORE, Schema::SQL::UNIQUE, Schema::SQL::UNSIGNED

Instance Attribute Summary collapse

Attributes inherited from Database

#loggers, #opts, #pool, #prepared_statements, #quote_identifiers

Instance Method Summary collapse

Methods inherited from Database

#<<, #[], adapter_class, adapter_scheme, #add_column, #add_index, #alter_table, #call, connect, #create_or_replace_view, #create_table, #create_table!, #create_view, #drop_column, #drop_index, #drop_table, #drop_view, #fetch, #from, #get, #inspect, #log_info, #logger, #logger=, #multi_threaded?, #query, quote_identifiers=, #quote_identifiers?, #rename_column, #rename_table, #select, #serial_primary_key_options, #set_column_default, #set_column_type, single_threaded=, #single_threaded?, #synchronize, #table_exists?, #test_connection, #typecast_value

Methods included from Schema::SQL

#alter_table_sql, #alter_table_sql_list, #auto_increment_sql, #column_definition_sql, #column_list_sql, #column_references_sql, #constraint_definition_sql, #create_table_sql_list, #default_index_name, #drop_index_sql, #drop_table_sql, #filter_expr, #index_definition_sql, #index_list_sql_list, #literal, #on_delete_clause, #quote_identifier, #rename_table_sql, #schema, #schema_utility_dataset

Constructor Details

#initialize(opts) ⇒ Database

Call the DATABASE_SETUP proc directly after initialization, so the object always uses sub adapter specific code. Also, raise an error immediately if the connection doesn’t have a uri, since JDBC requires one.

Raises:



84
85
86
87
88
89
90
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 84

def initialize(opts)
  super(opts)
  raise(Error, "No connection string specified") unless uri
  if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
    prok.call(self)
  end
end

Instance Attribute Details

#database_type ⇒ Object (readonly)

The type of database we are connecting to



78
79
80
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 78

def database_type
  @database_type
end

Instance Method Details

#connect(server) ⇒ Object

Connect to the database using JavaSQL::DriverManager.getConnection.



93
94
95
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 93

def connect(server)
  setup_connection(JavaSQL::DriverManager.getConnection(uri(server_opts(server))))
end

#dataset(opts = nil) ⇒ Object

Return instances of JDBC::Dataset with the given opts.



98
99
100
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 98

def dataset(opts = nil)
  JDBC::Dataset.new(self, opts)
end

#disconnect ⇒ Object

Close all adapter connections



103
104
105
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 103

def disconnect
  @pool.disconnect {|c| c.close}
end

#execute(sql, opts = {}, &block) ⇒ Object Also known as: execute_dui

Execute the given SQL. If a block is given, if should be a SELECT statement or something else that returns rows.



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 109

def execute(sql, opts={}, &block)
  return execute_prepared_statement(sql, opts, &block) if sql.is_one_of?(Symbol, Dataset)
  log_info(sql)
  synchronize(opts[:server]) do |conn|
    stmt = conn.createStatement
    begin
      if block_given?
        yield stmt.executeQuery(sql)
      else
        case opts[:type]
        when :ddl
          stmt.execute(sql)
        when :insert
          stmt.executeUpdate(sql)
          last_insert_id(conn, opts)
        else
          stmt.executeUpdate(sql)
        end
      end
    rescue NativeException, JavaSQL::SQLException => e
      raise_error(e)
    ensure
      stmt.close
    end
  end
end

#execute_ddl(sql, opts = {}) ⇒ Object

Execute the given DDL SQL, which should not return any values or rows.



139
140
141
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 139

def execute_ddl(sql, opts={})
  execute(sql, {:type=>:ddl}.merge(opts))
end

#execute_insert(sql, opts = {}) ⇒ Object

Execute the given INSERT SQL, returning the last inserted row id.



145
146
147
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 145

def execute_insert(sql, opts={})
  execute(sql, {:type=>:insert}.merge(opts))
end

#transaction(server = nil) ⇒ Object

Default transaction method that should work on most JDBC databases. Does not use the JDBC transaction methods, uses SQL BEGIN/ROLLBACK/COMMIT statements instead.



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 152

def transaction(server=nil)
  synchronize(server) do |conn|
    return yield(conn) if @transactions.include?(Thread.current)
    stmt = conn.createStatement
    begin
      log_info(begin_transaction_sql)
      stmt.execute(begin_transaction_sql)
      @transactions << Thread.current
      yield(conn)
    rescue Exception => e
      log_info(rollback_transaction_sql)
      stmt.execute(rollback_transaction_sql)
      transaction_error(e)
    ensure
      unless e
        log_info(commit_transaction_sql)
        stmt.execute(commit_transaction_sql)
      end
      stmt.close
      @transactions.delete(Thread.current)
    end
  end
end

#uri(opts = {}) ⇒ Object Also known as: url

The uri for this connection. You can specify the uri using the :uri, :url, or :database options. You don’t need to worry about this if you use Sequel.connect with the JDBC connectrion strings.



180
181
182
183
184
 
# File 'lib/sequel_core/adapters/jdbc.rb', line 180

def uri(opts={})
  opts = @opts.merge(opts)
  ur = opts[:uri] || opts[:url] || opts[:database]
  ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
end