sqlite3-ruby 1.2.5-x86-mswin32

Sign up to get free protection for your applications and to get access to all the features.
Files changed (44) hide show
  1. data/ChangeLog.cvs +88 -0
  2. data/History.txt +68 -0
  3. data/LICENSE +27 -0
  4. data/Manifest.txt +41 -0
  5. data/README.txt +56 -0
  6. data/Rakefile +5 -0
  7. data/ext/sqlite3_api/extconf.rb +10 -0
  8. data/ext/sqlite3_api/sqlite3_api.i +362 -0
  9. data/ext/sqlite3_api/sqlite3_api_wrap.c +5018 -0
  10. data/faq/faq.rb +145 -0
  11. data/faq/faq.yml +426 -0
  12. data/lib/1.8/sqlite3_api.so +0 -0
  13. data/lib/1.9/sqlite3_api.so +0 -0
  14. data/lib/sqlite3.rb +1 -0
  15. data/lib/sqlite3/constants.rb +49 -0
  16. data/lib/sqlite3/database.rb +721 -0
  17. data/lib/sqlite3/driver/dl/api.rb +152 -0
  18. data/lib/sqlite3/driver/dl/driver.rb +307 -0
  19. data/lib/sqlite3/driver/native/driver.rb +219 -0
  20. data/lib/sqlite3/errors.rb +68 -0
  21. data/lib/sqlite3/pragmas.rb +271 -0
  22. data/lib/sqlite3/resultset.rb +180 -0
  23. data/lib/sqlite3/statement.rb +231 -0
  24. data/lib/sqlite3/translator.rb +109 -0
  25. data/lib/sqlite3/value.rb +57 -0
  26. data/lib/sqlite3/version.rb +16 -0
  27. data/setup.rb +1333 -0
  28. data/tasks/benchmark.rake +9 -0
  29. data/tasks/faq.rake +9 -0
  30. data/tasks/gem.rake +32 -0
  31. data/tasks/native.rake +35 -0
  32. data/tasks/vendor_sqlite3.rake +104 -0
  33. data/test/bm.rb +140 -0
  34. data/test/driver/dl/tc_driver.rb +292 -0
  35. data/test/helper.rb +67 -0
  36. data/test/native-vs-dl.rb +126 -0
  37. data/test/test_database.rb +217 -0
  38. data/test/test_errors.rb +17 -0
  39. data/test/test_integration.rb +542 -0
  40. data/test/test_integration_open_close.rb +30 -0
  41. data/test/test_integration_pending.rb +111 -0
  42. data/test/test_integration_resultset.rb +159 -0
  43. data/test/test_integration_statement.rb +195 -0
  44. metadata +143 -0
@@ -0,0 +1,180 @@
1
+ require 'sqlite3/constants'
2
+ require 'sqlite3/errors'
3
+
4
+ module SQLite3
5
+
6
+ # The ResultSet object encapsulates the enumerability of a query's output.
7
+ # It is a simple cursor over the data that the query returns. It will
8
+ # very rarely (if ever) be instantiated directly. Instead, client's should
9
+ # obtain a ResultSet instance via Statement#execute.
10
+ class ResultSet
11
+ include Enumerable
12
+
13
+ # The class of which we return an object in case we want an Array as
14
+ # result. (ArrayFields is installed.)
15
+ class ArrayWithTypes < Array
16
+ attr_accessor :types
17
+ end
18
+
19
+ # The class of which we return an object in case we want an Array as
20
+ # result. (ArrayFields is not installed.)
21
+ class ArrayWithTypesAndFields < Array
22
+ attr_accessor :types
23
+ attr_accessor :fields
24
+ end
25
+
26
+ # The class of which we return an object in case we want a Hash as
27
+ # result.
28
+ class HashWithTypes < Hash
29
+ attr_accessor :types
30
+ end
31
+
32
+ # Create a new ResultSet attached to the given database, using the
33
+ # given sql text.
34
+ def initialize( db, stmt )
35
+ @db = db
36
+ @driver = @db.driver
37
+ @stmt = stmt
38
+ commence
39
+ end
40
+
41
+ # A convenience method for compiling the virtual machine and stepping
42
+ # to the first row of the result set.
43
+ def commence
44
+ result = @driver.step( @stmt.handle )
45
+ if result == Constants::ErrorCode::ERROR
46
+ @driver.reset( @stmt.handle )
47
+ end
48
+ check result
49
+ @first_row = true
50
+ end
51
+ private :commence
52
+
53
+ def check( result )
54
+ @eof = ( result == Constants::ErrorCode::DONE )
55
+ found = ( result == Constants::ErrorCode::ROW )
56
+ Error.check( result, @db ) unless @eof || found
57
+ end
58
+ private :check
59
+
60
+ # Reset the cursor, so that a result set which has reached end-of-file
61
+ # can be rewound and reiterated.
62
+ def reset( *bind_params )
63
+ @stmt.must_be_open!
64
+ @stmt.reset!(false)
65
+ @driver.reset( @stmt.handle )
66
+ @stmt.bind_params( *bind_params )
67
+ @eof = false
68
+ commence
69
+ end
70
+
71
+ # Query whether the cursor has reached the end of the result set or not.
72
+ def eof?
73
+ @eof
74
+ end
75
+
76
+ # Obtain the next row from the cursor. If there are no more rows to be
77
+ # had, this will return +nil+. If type translation is active on the
78
+ # corresponding database, the values in the row will be translated
79
+ # according to their types.
80
+ #
81
+ # The returned value will be an array, unless Database#results_as_hash has
82
+ # been set to +true+, in which case the returned value will be a hash.
83
+ #
84
+ # For arrays, the column names are accessible via the +fields+ property,
85
+ # and the column types are accessible via the +types+ property.
86
+ #
87
+ # For hashes, the column names are the keys of the hash, and the column
88
+ # types are accessible via the +types+ property.
89
+ def next
90
+ return nil if @eof
91
+
92
+ @stmt.must_be_open!
93
+
94
+ unless @first_row
95
+ result = @driver.step( @stmt.handle )
96
+ check result
97
+ end
98
+
99
+ @first_row = false
100
+
101
+ unless @eof
102
+ row = []
103
+ @driver.data_count( @stmt.handle ).times do |column|
104
+ type = @driver.column_type( @stmt.handle, column )
105
+
106
+ if type == Constants::ColumnType::TEXT
107
+ row << @driver.column_text( @stmt.handle, column )
108
+ elsif type == Constants::ColumnType::NULL
109
+ row << nil
110
+ elsif type == Constants::ColumnType::BLOB
111
+ row << @driver.column_blob( @stmt.handle, column )
112
+ else
113
+ row << @driver.column_text( @stmt.handle, column )
114
+ end
115
+ end
116
+
117
+ if @db.type_translation
118
+ row = @stmt.types.zip( row ).map do |type, value|
119
+ @db.translator.translate( type, value )
120
+ end
121
+ end
122
+
123
+ if @db.results_as_hash
124
+ new_row = HashWithTypes[ *( @stmt.columns.zip( row ).to_a.flatten ) ]
125
+ row.each_with_index { |value,idx|
126
+ value.taint
127
+ new_row[idx] = value
128
+ }
129
+ row = new_row
130
+ else
131
+ if row.respond_to?(:fields)
132
+ row = ArrayWithTypes.new(row)
133
+ else
134
+ row = ArrayWithTypesAndFields.new(row)
135
+ end
136
+ row.fields = @stmt.columns
137
+ row.each { |column| column.taint }
138
+ end
139
+
140
+ row.types = @stmt.types
141
+
142
+ return row
143
+ end
144
+
145
+ nil
146
+ end
147
+
148
+ # Required by the Enumerable mixin. Provides an internal iterator over the
149
+ # rows of the result set.
150
+ def each
151
+ while row=self.next
152
+ yield row
153
+ end
154
+ end
155
+
156
+ # Closes the statement that spawned this result set.
157
+ # <em>Use with caution!</em> Closing a result set will automatically
158
+ # close any other result sets that were spawned from the same statement.
159
+ def close
160
+ @stmt.close
161
+ end
162
+
163
+ # Queries whether the underlying statement has been closed or not.
164
+ def closed?
165
+ @stmt.closed?
166
+ end
167
+
168
+ # Returns the types of the columns returned by this result set.
169
+ def types
170
+ @stmt.types
171
+ end
172
+
173
+ # Returns the names of the columns returned by this result set.
174
+ def columns
175
+ @stmt.columns
176
+ end
177
+
178
+ end
179
+
180
+ end
@@ -0,0 +1,231 @@
1
+ require 'sqlite3/errors'
2
+ require 'sqlite3/resultset'
3
+
4
+ class String
5
+ def to_blob
6
+ SQLite3::Blob.new( self )
7
+ end
8
+ end
9
+
10
+ module SQLite3
11
+
12
+ # A class for differentiating between strings and blobs, when binding them
13
+ # into statements.
14
+ class Blob < String; end
15
+
16
+ # A statement represents a prepared-but-unexecuted SQL query. It will rarely
17
+ # (if ever) be instantiated directly by a client, and is most often obtained
18
+ # via the Database#prepare method.
19
+ class Statement
20
+
21
+ # This is any text that followed the first valid SQL statement in the text
22
+ # with which the statement was initialized. If there was no trailing text,
23
+ # this will be the empty string.
24
+ attr_reader :remainder
25
+
26
+ # The underlying opaque handle used to access the SQLite @driver.
27
+ attr_reader :handle
28
+
29
+ # Create a new statement attached to the given Database instance, and which
30
+ # encapsulates the given SQL text. If the text contains more than one
31
+ # statement (i.e., separated by semicolons), then the #remainder property
32
+ # will be set to the trailing text.
33
+ def initialize( db, sql, utf16=false )
34
+ raise ArgumentError, "nil argument passed as sql text" unless sql
35
+ @db = db
36
+ @driver = @db.driver
37
+ @closed = false
38
+ @results = @columns = nil
39
+ result, @handle, @remainder = @driver.prepare( @db.handle, sql )
40
+ Error.check( result, @db )
41
+ end
42
+
43
+ # Closes the statement by finalizing the underlying statement
44
+ # handle. The statement must not be used after being closed.
45
+ def close
46
+ must_be_open!
47
+ @closed = true
48
+ @driver.finalize( @handle )
49
+ end
50
+
51
+ # Returns true if the underlying statement has been closed.
52
+ def closed?
53
+ @closed
54
+ end
55
+
56
+ # Binds the given variables to the corresponding placeholders in the SQL
57
+ # text.
58
+ #
59
+ # See Database#execute for a description of the valid placeholder
60
+ # syntaxes.
61
+ #
62
+ # Example:
63
+ #
64
+ # stmt = db.prepare( "select * from table where a=? and b=?" )
65
+ # stmt.bind_params( 15, "hello" )
66
+ #
67
+ # See also #execute, #bind_param, Statement#bind_param, and
68
+ # Statement#bind_params.
69
+ def bind_params( *bind_vars )
70
+ index = 1
71
+ bind_vars.flatten.each do |var|
72
+ if Hash === var
73
+ var.each { |key, val| bind_param key, val }
74
+ else
75
+ bind_param index, var
76
+ index += 1
77
+ end
78
+ end
79
+ end
80
+
81
+ # Binds value to the named (or positional) placeholder. If +param+ is a
82
+ # Fixnum, it is treated as an index for a positional placeholder.
83
+ # Otherwise it is used as the name of the placeholder to bind to.
84
+ #
85
+ # See also #bind_params.
86
+ def bind_param( param, value )
87
+ must_be_open!
88
+ reset! if active?
89
+ if Fixnum === param
90
+ case value
91
+ when Bignum then
92
+ @driver.bind_int64( @handle, param, value )
93
+ when Integer then
94
+ if value >= (2 ** 31)
95
+ @driver.bind_int64( @handle, param, value )
96
+ else
97
+ @driver.bind_int( @handle, param, value )
98
+ end
99
+ when Numeric then
100
+ @driver.bind_double( @handle, param, value.to_f )
101
+ when Blob then
102
+ @driver.bind_blob( @handle, param, value )
103
+ when nil then
104
+ @driver.bind_null( @handle, param )
105
+ else
106
+ @driver.bind_text( @handle, param, value )
107
+ end
108
+ else
109
+ param = param.to_s
110
+ param = ":#{param}" unless param[0] == ?:
111
+ index = @driver.bind_parameter_index( @handle, param )
112
+ raise Exception, "no such bind parameter '#{param}'" if index == 0
113
+ bind_param index, value
114
+ end
115
+ end
116
+
117
+ # Execute the statement. This creates a new ResultSet object for the
118
+ # statement's virtual machine. If a block was given, the new ResultSet will
119
+ # be yielded to it; otherwise, the ResultSet will be returned.
120
+ #
121
+ # Any parameters will be bound to the statement using #bind_params.
122
+ #
123
+ # Example:
124
+ #
125
+ # stmt = db.prepare( "select * from table" )
126
+ # stmt.execute do |result|
127
+ # ...
128
+ # end
129
+ #
130
+ # See also #bind_params, #execute!.
131
+ def execute( *bind_vars )
132
+ must_be_open!
133
+ reset! if active?
134
+
135
+ bind_params(*bind_vars) unless bind_vars.empty?
136
+ @results = ResultSet.new( @db, self )
137
+
138
+ if block_given?
139
+ yield @results
140
+ else
141
+ return @results
142
+ end
143
+ end
144
+
145
+ # Execute the statement. If no block was given, this returns an array of
146
+ # rows returned by executing the statement. Otherwise, each row will be
147
+ # yielded to the block.
148
+ #
149
+ # Any parameters will be bound to the statement using #bind_params.
150
+ #
151
+ # Example:
152
+ #
153
+ # stmt = db.prepare( "select * from table" )
154
+ # stmt.execute! do |row|
155
+ # ...
156
+ # end
157
+ #
158
+ # See also #bind_params, #execute.
159
+ def execute!( *bind_vars )
160
+ result = execute( *bind_vars )
161
+ rows = [] unless block_given?
162
+ while row = result.next
163
+ if block_given?
164
+ yield row
165
+ else
166
+ rows << row
167
+ end
168
+ end
169
+ rows
170
+ end
171
+
172
+ # Resets the statement. This is typically done internally, though it might
173
+ # occassionally be necessary to manually reset the statement.
174
+ def reset!(clear_result=true)
175
+ @driver.reset(@handle)
176
+ @results = nil if clear_result
177
+ end
178
+
179
+ # Returns true if the statement is currently active, meaning it has an
180
+ # open result set.
181
+ def active?
182
+ not @results.nil?
183
+ end
184
+
185
+ # Return an array of the column names for this statement. Note that this
186
+ # may execute the statement in order to obtain the metadata; this makes it
187
+ # a (potentially) expensive operation.
188
+ def columns
189
+ get_metadata unless @columns
190
+ return @columns
191
+ end
192
+
193
+ # Return an array of the data types for each column in this statement. Note
194
+ # that this may execute the statement in order to obtain the metadata; this
195
+ # makes it a (potentially) expensive operation.
196
+ def types
197
+ get_metadata unless defined?(@types)
198
+ @types
199
+ end
200
+
201
+ # A convenience method for obtaining the metadata about the query. Note
202
+ # that this will actually execute the SQL, which means it can be a
203
+ # (potentially) expensive operation.
204
+ def get_metadata
205
+ must_be_open!
206
+
207
+ @columns = []
208
+ @types = []
209
+
210
+ column_count = @driver.column_count( @handle )
211
+ column_count.times do |column|
212
+ @columns << @driver.column_name( @handle, column )
213
+ @types << @driver.column_decltype( @handle, column )
214
+ end
215
+
216
+ @columns.freeze
217
+ @types.freeze
218
+ end
219
+ private :get_metadata
220
+
221
+ # Performs a sanity check to ensure that the statement is not
222
+ # closed. If it is, an exception is raised.
223
+ def must_be_open! # :nodoc:
224
+ if @closed
225
+ raise SQLite3::Exception, "cannot use a closed statement"
226
+ end
227
+ end
228
+
229
+ end
230
+
231
+ end
@@ -0,0 +1,109 @@
1
+ require 'time'
2
+ require 'date'
3
+
4
+ module SQLite3
5
+
6
+ # The Translator class encapsulates the logic and callbacks necessary for
7
+ # converting string data to a value of some specified type. Every Database
8
+ # instance may have a Translator instance, in order to assist in type
9
+ # translation (Database#type_translation).
10
+ #
11
+ # Further, applications may define their own custom type translation logic
12
+ # by registering translator blocks with the corresponding database's
13
+ # translator instance (Database#translator).
14
+ class Translator
15
+
16
+ # Create a new Translator instance. It will be preinitialized with default
17
+ # translators for most SQL data types.
18
+ def initialize
19
+ @translators = Hash.new( proc { |type,value| value } )
20
+ @type_name_cache = {}
21
+ register_default_translators
22
+ end
23
+
24
+ # Add a new translator block, which will be invoked to process type
25
+ # translations to the given type. The type should be an SQL datatype, and
26
+ # may include parentheses (i.e., "VARCHAR(30)"). However, any parenthetical
27
+ # information is stripped off and discarded, so type translation decisions
28
+ # are made solely on the "base" type name.
29
+ #
30
+ # The translator block itself should accept two parameters, "type" and
31
+ # "value". In this case, the "type" is the full type name (including
32
+ # parentheses), so the block itself may include logic for changing how a
33
+ # type is translated based on the additional data. The "value" parameter
34
+ # is the (string) data to convert.
35
+ #
36
+ # The block should return the translated value.
37
+ def add_translator( type, &block ) # :yields: type, value
38
+ @translators[ type_name( type ) ] = block
39
+ end
40
+
41
+ # Translate the given string value to a value of the given type. In the
42
+ # absense of an installed translator block for the given type, the value
43
+ # itself is always returned. Further, +nil+ values are never translated,
44
+ # and are always passed straight through regardless of the type parameter.
45
+ def translate( type, value )
46
+ unless value.nil?
47
+ @translators[ type_name( type ) ].call( type, value )
48
+ end
49
+ end
50
+
51
+ # A convenience method for working with type names. This returns the "base"
52
+ # type name, without any parenthetical data.
53
+ def type_name( type )
54
+ @type_name_cache[type] ||= begin
55
+ type = "" if type.nil?
56
+ type = $1 if type =~ /^(.*?)\(/
57
+ type.upcase
58
+ end
59
+ end
60
+ private :type_name
61
+
62
+ # Register the default translators for the current Translator instance.
63
+ # This includes translators for most major SQL data types.
64
+ def register_default_translators
65
+ [ "time",
66
+ "timestamp" ].each { |type| add_translator( type ) { |t, v| Time.parse( v ) } }
67
+
68
+ add_translator( "date" ) { |t,v| Date.parse(v) }
69
+ add_translator( "datetime" ) { |t,v| DateTime.parse(v) }
70
+
71
+ [ "decimal",
72
+ "float",
73
+ "numeric",
74
+ "double",
75
+ "real",
76
+ "dec",
77
+ "fixed" ].each { |type| add_translator( type ) { |t,v| v.to_f } }
78
+
79
+ [ "integer",
80
+ "smallint",
81
+ "mediumint",
82
+ "int",
83
+ "bigint" ].each { |type| add_translator( type ) { |t,v| v.to_i } }
84
+
85
+ [ "bit",
86
+ "bool",
87
+ "boolean" ].each do |type|
88
+ add_translator( type ) do |t,v|
89
+ !( v.strip.gsub(/00+/,"0") == "0" ||
90
+ v.downcase == "false" ||
91
+ v.downcase == "f" ||
92
+ v.downcase == "no" ||
93
+ v.downcase == "n" )
94
+ end
95
+ end
96
+
97
+ add_translator( "tinyint" ) do |type, value|
98
+ if type =~ /\(\s*1\s*\)/
99
+ value.to_i == 1
100
+ else
101
+ value.to_i
102
+ end
103
+ end
104
+ end
105
+ private :register_default_translators
106
+
107
+ end
108
+
109
+ end