Class Index [+]

Quicksearch

Sequel::Oracle

Constants

PS_TYPES

Public Instance Methods

do(sql, opts={}, &block) click to toggle source
Alias for: execute
execute(sql, opts={}, &block) click to toggle source
    # File lib/sequel/adapters/oracle.rb, line 60
60:       def execute(sql, opts={}, &block)
61:         _execute(nil, sql, opts, &block)
62:       end
Also aliased as: do
execute_insert(sql, opts={}) click to toggle source
    # File lib/sequel/adapters/oracle.rb, line 65
65:       def execute_insert(sql, opts={})
66:         _execute(:insert, sql, opts)
67:       end

Private Instance Methods

_execute(type, sql, opts={}, &block) click to toggle source
    # File lib/sequel/adapters/oracle.rb, line 71
71:       def _execute(type, sql, opts={}, &block)
72:         synchronize(opts[:server]) do |conn|
73:           begin
74:             return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
75:             if args = opts[:arguments]
76:               r = conn.parse(sql)
77:               args = cursor_bind_params(conn, r, args)
78:               nr = log_yield(sql, args){r.exec}
79:               r = nr unless block_given?
80:             else
81:               r = log_yield(sql){conn.exec(sql)}
82:             end
83:             if block_given?
84:               begin
85:                 yield(r)
86:               ensure
87:                 r.close
88:               end
89:             elsif type == :insert
90:               last_insert_id(conn, opts)
91:             else
92:               r
93:             end
94:           rescue OCIException, RuntimeError => e
95:             # ruby-oci8 is naughty and raises strings in some places
96:             raise_error(e)
97:           end
98:         end
99:       end
begin_transaction(conn, opts={}) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 179
179:       def begin_transaction(conn, opts={})
180:         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
181:       end
commit_transaction(conn, opts={}) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 183
183:       def commit_transaction(conn, opts={})
184:         log_yield(TRANSACTION_COMMIT){conn.commit}
185:       end
cursor_bind_params(conn, cursor, args) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 104
104:       def cursor_bind_params(conn, cursor, args)
105:         cursor
106:         i = 0
107:         args.map do |arg, type|
108:           i += 1
109:           case arg
110:           when true
111:             arg = 'Y'
112:           when false
113:             arg = 'N'
114:           when BigDecimal
115:             arg = arg.to_f
116:           when ::Sequel::SQL::Blob
117:             raise Error, "Sequel's oracle adapter does not currently support using a blob in a bound variable"
118:           end
119:           if t = PS_TYPES[type]
120:             cursor.bind_param(i, arg, t)
121:           else
122:             cursor.bind_param(i, arg, arg.class)
123:           end
124:           arg
125:         end
126:       end
disconnect_connection(c) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 187
187:       def disconnect_connection(c)
188:         c.logoff
189:       rescue OCIInvalidHandle
190:         nil
191:       end
disconnect_error?(e, opts) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 193
193:       def disconnect_error?(e, opts)
194:         super || (e.is_a?(::OCIError) && CONNECTION_ERROR_CODES.include?(e.code))
195:       end
execute_prepared_statement(conn, type, name, opts) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 128
128:       def execute_prepared_statement(conn, type, name, opts)
129:         ps = prepared_statement(name)
130:         sql = ps.prepared_sql
131:         if cursora = conn.prepared_statements[name]
132:           cursor, cursor_sql = cursora
133:           if cursor_sql != sql
134:             cursor.close
135:             cursor = nil
136:           end
137:         end
138:         unless cursor
139:           cursor = log_yield("PREPARE #{name}: #{sql}"){conn.parse(sql)}
140:           conn.prepared_statements[name] = [cursor, sql]
141:         end
142:         args = cursor_bind_params(conn, cursor, opts[:arguments])
143:         log_sql = "EXECUTE #{name}"
144:         if ps.log_sql
145:           log_sql << " ("
146:           log_sql << sql
147:           log_sql << ")"
148:         end
149:         r = log_yield(log_sql, args){cursor.exec}
150:         if block_given?
151:           yield(cursor)
152:         elsif type == :insert
153:           last_insert_id(conn, opts)
154:         else
155:           r
156:         end
157:       end
last_insert_id(conn, opts) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 159
159:       def last_insert_id(conn, opts)
160:         unless sequence = opts[:sequence]
161:           if t = opts[:table]
162:             sequence = sequence_for_table(t)
163:           end
164:         end
165:         if sequence
166:           sql = "SELECT #{literal(sequence)}.currval FROM dual"
167:           begin
168:             cursor = log_yield(sql){conn.exec(sql)}
169:             row = cursor.fetch
170:             row.each{|v| return (v.to_i if v)}
171:           rescue OCIError
172:             nil
173:           ensure
174:             cursor.close if cursor
175:           end
176:         end
177:       end
oracle_column_type(h) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 197
197:       def oracle_column_type(h)
198:         case h[:oci8_type]
199:         when :number
200:           case h[:scale]
201:           when 0
202:             :integer
203:           when 127
204:             :float
205:           else
206:             :decimal
207:           end
208:         when :date
209:           :datetime
210:         else
211:           schema_column_type(h[:db_type])
212:         end
213:       end
remove_transaction(conn, committed) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 215
215:       def remove_transaction(conn, committed)
216:         conn.autocommit = true
217:       ensure
218:         super
219:       end
rollback_transaction(conn, opts={}) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 221
221:       def rollback_transaction(conn, opts={})
222:         log_yield(TRANSACTION_ROLLBACK){conn.rollback}
223:       end
schema_parse_table(table, opts={}) click to toggle source
     # File lib/sequel/adapters/oracle.rb, line 225
225:       def schema_parse_table(table, opts={})
226:         schema, table = schema_and_table(table)
227:         schema ||= opts[:schema]
228:         schema_and_table = if ds = opts[:dataset]
229:           ds.literal(schema ? SQL::QualifiedIdentifier.new(schema, table) : SQL::Identifier.new(table))
230:         else
231:           "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
232:         end
233:         table_schema = []
234:         m = output_identifier_meth(ds)
235:         im = input_identifier_meth(ds)
236: 
237:         # Primary Keys
238:         ds = metadata_dataset.from(:all_constraints___cons, :all_cons_columns___cols).
239:           where(:cols__table_name=>im.call(table), :cons__constraint_type=>'P',
240:                 :cons__constraint_name=>:cols__constraint_name, :cons__owner=>:cols__owner)
241:         ds = ds.where(:cons__owner=>im.call(schema)) if schema
242:         pks = ds.select_map(:cols__column_name)
243: 
244:         # Default values
245:         defaults = begin
246:           metadata_dataset.from(:user_tab_cols).
247:             where(:table_name=>im.call(table)).
248:             to_hash(:column_name, :data_default)
249:         rescue DatabaseError
250:           {}
251:         end
252: 
253:         metadata = synchronize(opts[:server]) do |conn|
254:           begin
255:           log_yield("Connection.describe_table"){conn.describe_table(schema_and_table)}
256:           rescue OCIError => e
257:             raise_error(e)
258:           end
259:         end
260:         metadata.columns.each do |column|
261:           h = {
262:               :primary_key => pks.include?(column.name),
263:               :default => defaults[column.name],
264:               :oci8_type => column.data_type,
265:               :db_type => column.type_string.split(' ')[0],
266:               :type_string => column.type_string,
267:               :charset_form => column.charset_form,
268:               :char_used => column.char_used?,
269:               :char_size => column.char_size,
270:               :data_size => column.data_size,
271:               :precision => column.precision,
272:               :scale => column.scale,
273:               :fsprecision => column.fsprecision,
274:               :lfprecision => column.lfprecision,
275:               :allow_null => column.nullable?
276:           }
277:           h[:type] = oracle_column_type(h)
278:           table_schema << [m.call(column.name), h]
279:         end
280:         table_schema
281:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.