Methods
Constants
STATIC = ::DL::PtrData.new(0)
TRANSIENT = ::DL::PtrData.new(-1)
Public Class methods
api_delegate( name )
     # File lib/sqlite3/driver/dl/driver.rb, line 227
227:     def self.api_delegate( name )
228:       define_method( name ) { |*args| API.send( "sqlite3_#{name}", *args ) }
229:     end
Public Instance methods
aggregate_context( context )
     # File lib/sqlite3/driver/dl/driver.rb, line 190
190:     def aggregate_context( context )
191:       ptr = API.sqlite3_aggregate_context( context, 4 )
192:       ptr.free = nil
193:       obj = ( ptr ? ptr.to_object : nil )
194:       if obj.nil?
195:         obj = Hash.new
196:         ptr.set_object obj
197:       end
198:       obj
199:     end
bind_blob( stmt, index, value )
     # File lib/sqlite3/driver/dl/driver.rb, line 201
201:     def bind_blob( stmt, index, value )
202:       s = value.to_s
203:       API.sqlite3_bind_blob( stmt, index, s, s.length, TRANSIENT )
204:     end
bind_text( stmt, index, value, utf16=false )
     # File lib/sqlite3/driver/dl/driver.rb, line 206
206:     def bind_text( stmt, index, value, utf16=false )
207:       s = value.to_s
208:       method = ( utf16 ? :sqlite3_bind_text16 : :sqlite3_bind_text )
209:       API.send( method, stmt, index, s, s.length, TRANSIENT )
210:     end
busy_handler( db, data=nil, &block )
     # File lib/sqlite3/driver/dl/driver.rb, line 113
113:     def busy_handler( db, data=nil, &block )
114:       @busy_handler = block
115: 
116:       unless @busy_handler_callback
117:         @busy_handler_callback = ::DL.callback( "IPI" ) do |cookie, timeout|
118:           @busy_handler.call( cookie, timeout ) || 0
119:         end
120:       end
121: 
122:       API.sqlite3_busy_handler( db, block&&@busy_handler_callback, data )
123:     end
column_blob( stmt, column )
    # File lib/sqlite3/driver/dl/driver.rb, line 95
95:     def column_blob( stmt, column )
96:       blob = API.sqlite3_column_blob( stmt, column )
97:       blob.free = nil
98:       blob.to_s( API.sqlite3_column_bytes( stmt, column ) )
99:     end
column_decltype( stmt, column )
     # File lib/sqlite3/driver/dl/driver.rb, line 222
222:     def column_decltype( stmt, column )
223:       result = API.sqlite3_column_decltype( stmt, column )
224:       result ? result.to_s : nil
225:     end
column_name( stmt, column )
     # File lib/sqlite3/driver/dl/driver.rb, line 217
217:     def column_name( stmt, column )
218:       result = API.sqlite3_column_name( stmt, column )
219:       result ? result.to_s : nil
220:     end
column_text( stmt, column )
     # File lib/sqlite3/driver/dl/driver.rb, line 212
212:     def column_text( stmt, column )
213:       result = API.sqlite3_column_text( stmt, column )
214:       result ? result.to_s : nil
215:     end
commit_hook( db, data=nil, &block )
     # File lib/sqlite3/driver/dl/driver.rb, line 280
280:       def commit_hook( db, data=nil, &block )
281:         @commit_hook_handler = block
282: 
283:         unless @commit_hook_handler_callback
284:           @commit_hook_handler_callback = ::DL.callback( "IP" ) do |cookie|
285:             @commit_hook_handler.call( cookie )
286:           end
287:         end
288: 
289:         API.sqlite3_commit_hook( db, block&&@commit_hook_handler_callback,
290:           data )
291:       end
complete?( sql, utf16=false )
    # File lib/sqlite3/driver/dl/driver.rb, line 67
67:     def complete?( sql, utf16=false )
68:       API.send( utf16 ? :sqlite3_complete16 : :sqlite3_complete, sql+"\0" )
69:     end
create_function( db, name, args, text, cookie, func, step, final )
     # File lib/sqlite3/driver/dl/driver.rb, line 152
152:     def create_function( db, name, args, text, cookie,
153:       func, step, final )
154:     # begin
155:       if @func_handler_callback.nil? && func
156:         @func_handler_callback = ::DL.callback( "0PIP" ) do |context,nargs,args|
157:           args = args.to_s(nargs*4).unpack("L*").map {|i| ::DL::PtrData.new(i)}
158:           data = API.sqlite3_user_data( context ).to_object
159:           data[:func].call( context, *args )
160:         end
161:       end
162: 
163:       if @step_handler_callback.nil? && step
164:         @step_handler_callback = ::DL.callback( "0PIP" ) do |context,nargs,args|
165:           args = args.to_s(nargs*4).unpack("L*").map {|i| ::DL::PtrData.new(i)}
166:           data = API.sqlite3_user_data( context ).to_object
167:           data[:step].call( context, *args )
168:         end
169:       end
170: 
171:       if @final_handler_callback.nil? && final
172:         @final_handler_callback = ::DL.callback( "0P" ) do |context|
173:           data = API.sqlite3_user_data( context ).to_object
174:           data[:final].call( context )
175:         end
176:       end
177: 
178:       data = { :cookie => cookie,
179:                :name => name,
180:                :func => func,
181:                :step => step,
182:                :final => final }
183: 
184:       API.sqlite3_create_function( db, name, args, text, data,
185:         ( func ? @func_handler_callback : nil ),
186:         ( step ? @step_handler_callback : nil ),
187:         ( final ? @final_handler_callback : nil ) )
188:     end
errmsg( db, utf16=false )
    # File lib/sqlite3/driver/dl/driver.rb, line 44
44:     def errmsg( db, utf16=false )
45:       if utf16
46:         msg = API.sqlite3_errmsg16( db )
47:         msg.free = nil
48:         msg.to_s(utf16_length(msg))
49:       else
50:         API.sqlite3_errmsg( db )
51:       end
52:     end
open( filename, utf16=false )
    # File lib/sqlite3/driver/dl/driver.rb, line 37
37:     def open( filename, utf16=false )
38:       handle = ::DL::PtrData.new(0)
39:       result = API.send( ( utf16 ? :sqlite3_open16 : :sqlite3_open ),
40:         filename+"\0", handle.ref )
41:       [ result, handle ]
42:     end
prepare( db, sql, utf16=false )
    # File lib/sqlite3/driver/dl/driver.rb, line 54
54:     def prepare( db, sql, utf16=false )
55:       handle = ::DL::PtrData.new(0)
56:       remainder = ::DL::PtrData.new(0)
57: 
58:       result = API.send( ( utf16 ? :sqlite3_prepare16 : :sqlite3_prepare ),
59:          db, sql+"\0", sql.length, handle.ref, remainder.ref )
60: 
61:       args = utf16 ? [ utf16_length(remainder) ] : []
62:       remainder = remainder.to_s( *args )
63: 
64:       [ result, handle, remainder ]
65:     end
progress_handler( db, n, data=nil, &block )
     # File lib/sqlite3/driver/dl/driver.rb, line 267
267:       def progress_handler( db, n, data=nil, &block )
268:         @progress_handler = block
269: 
270:         unless @progress_handler_callback
271:           @progress_handler_callback = ::DL.callback( "IP" ) do |cookie|
272:             @progress_handler.call( cookie )
273:           end
274:         end
275: 
276:         API.sqlite3_progress_handler( db, n, block&&@progress_handler_callback,
277:           data )
278:       end
result_text( func, text, utf16=false )
     # File lib/sqlite3/driver/dl/driver.rb, line 101
101:     def result_text( func, text, utf16=false )
102:       method = case utf16
103:         when false, nil then :sqlite3_result_text
104:         when :le then :sqlite3_result_text16le
105:         when :be then :sqlite3_result_text16be
106:         else :sqlite3_result_text16
107:       end
108: 
109:       s = text.to_s
110:       API.send( method, func, s, s.length, TRANSIENT )
111:     end
set_authorizer( db, data=nil, &block )
     # File lib/sqlite3/driver/dl/driver.rb, line 125
125:     def set_authorizer( db, data=nil, &block )
126:       @authorizer_handler = block
127: 
128:       unless @authorizer_handler_callback
129:         @authorizer_handler_callback = ::DL.callback( "IPIPPPP"
130:         ) do |cookie,mode,a,b,c,d|
131:           @authorizer_handler.call( cookie, mode,
132:             a&&a.to_s, b&&b.to_s, c&&c.to_s, d&&d.to_s ) || 0
133:         end
134:       end
135: 
136:       API.sqlite3_set_authorizer( db, block&&@authorizer_handler_callback,
137:         data )
138:     end
trace( db, data=nil, &block )
     # File lib/sqlite3/driver/dl/driver.rb, line 140
140:     def trace( db, data=nil, &block )
141:       @trace_handler = block
142: 
143:       unless @trace_handler_callback
144:         @trace_handler_callback = ::DL.callback( "IPS" ) do |cookie,sql|
145:           @trace_handler.call( cookie ? cookie.to_object : nil, sql ) || 0
146:         end
147:       end
148: 
149:       API.sqlite3_trace( db, block&&@trace_handler_callback, data )
150:     end
value_blob( value )
    # File lib/sqlite3/driver/dl/driver.rb, line 71
71:     def value_blob( value )
72:       blob = API.sqlite3_value_blob( value )
73:       blob.free = nil
74:       blob.to_s( API.sqlite3_value_bytes( value ) )
75:     end
value_text( value, utf16=false )
    # File lib/sqlite3/driver/dl/driver.rb, line 77
77:     def value_text( value, utf16=false )
78:       method = case utf16
79:         when nil, false then :sqlite3_value_text
80:         when :le then :sqlite3_value_text16le
81:         when :be then :sqlite3_value_text16be
82:         else :sqlite3_value_text16
83:       end
84: 
85:       result = API.send( method, value )
86:       if utf16
87:         result.free = nil
88:         size = API.sqlite3_value_bytes( value )
89:         result = result.to_s( size )
90:       end
91: 
92:       result
93:     end