sqlite3 1.5.0 → 2.0.2

data/ChangeLog.cvs

@@ -1,88 +0,0 @@
-2005-01-05 09:40  minam
-
-	* Rakefile, sqlite3-ruby-win32.gemspec, sqlite3-ruby.gemspec: Added
-	  win32 gem.
-
-2005-01-05 07:31  minam
-
-	* Rakefile, test/tc_integration.rb, test/tests.rb: Added
-	  native-vs-dl benchmark to Rakefile. Added SQLITE3_DRIVERS
-	  environment variable to integration test to specify which
-	  driver(s) should be tested (defaults to "Native").
-
-2005-01-04 14:26  minam
-
-	* ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb,
-	  lib/sqlite3/driver/native/driver.rb, test/tc_database.rb,
-	  test/tc_integration.rb, test/tests.rb: Unit tests: done. Bugs:
-	  fixed.
-
-2005-01-03 23:13  minam
-
-	* ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb,
-	  lib/sqlite3/driver/dl/driver.rb,
-	  lib/sqlite3/driver/native/driver.rb, test/tc_integration.rb:
-	  Custom functions (aggregate and otherwise) are supported by the
-	  native driver now. Test cases for the same.
-
-2005-01-03 13:51  minam
-
-	* ext/sqlite3_api/MANIFEST, ext/sqlite3_api/extconf.rb,
-	  ext/sqlite3_api/post-clean.rb, ext/sqlite3_api/post-distclean.rb,
-	  ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb,
-	  lib/sqlite3/resultset.rb, lib/sqlite3/version.rb,
-	  lib/sqlite3/driver/dl/driver.rb,
-	  lib/sqlite3/driver/native/driver.rb, test/native-vs-dl.rb,
-	  test/tc_integration.rb: Added preliminary implementation of
-	  native driver (swig-based), and integration tests.
-
-2004-12-29 19:37  minam
-
-	* lib/sqlite3/driver/dl/driver.rb: Some fixes to allow the DL
-	  driver to work with Ruby 1.8.1.
-
-2004-12-29 14:52  minam
-
-	* lib/sqlite3/: database.rb, version.rb: Made #quote a class method
-	  (again). Bumped version to 0.6.
-
-2004-12-25 22:59  minam
-
-	* lib/sqlite3/driver/dl/api.rb: Added check for darwin in supported
-	  platforms (thanks to bitsweat).
-
-2004-12-22 12:38  minam
-
-	* Rakefile: Rakefile wasn't packaging the README file.
-
-2004-12-21 22:28  minam
-
-	* Rakefile, sqlite3-ruby.gemspec, test/bm.rb: Packaging now works.
-	  Added benchmarks.
-
-2004-12-21 21:45  minam
-
-	* LICENSE, README, Rakefile, setup.rb, sqlite3-ruby.gemspec,
-	  doc/faq/faq.rb, doc/faq/faq.yml, lib/sqlite3.rb,
-	  lib/sqlite3/statement.rb, lib/sqlite3/constants.rb,
-	  lib/sqlite3/database.rb, lib/sqlite3/resultset.rb,
-	  lib/sqlite3/translator.rb, lib/sqlite3/value.rb,
-	  lib/sqlite3/version.rb, lib/sqlite3/errors.rb,
-	  lib/sqlite3/pragmas.rb, lib/sqlite3/driver/dl/api.rb,
-	  lib/sqlite3/driver/dl/driver.rb, test/mocks.rb,
-	  test/tc_database.rb, test/tests.rb, test/driver/dl/tc_driver.rb:
-	  Initial import
-
-2004-12-21 21:45  minam
-
-	* LICENSE, README, Rakefile, setup.rb, sqlite3-ruby.gemspec,
-	  doc/faq/faq.rb, doc/faq/faq.yml, lib/sqlite3.rb,
-	  lib/sqlite3/statement.rb, lib/sqlite3/constants.rb,
-	  lib/sqlite3/database.rb, lib/sqlite3/resultset.rb,
-	  lib/sqlite3/translator.rb, lib/sqlite3/value.rb,
-	  lib/sqlite3/version.rb, lib/sqlite3/errors.rb,
-	  lib/sqlite3/pragmas.rb, lib/sqlite3/driver/dl/api.rb,
-	  lib/sqlite3/driver/dl/driver.rb, test/mocks.rb,
-	  test/tc_database.rb, test/tests.rb, test/driver/dl/tc_driver.rb:
-	  Initial revision
-

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/LICENSE-DEPENDENCIES

@@ -1,20 +0,0 @@
-# Vendored Dependency Licenses
-
-The library `sqlite3-ruby` (which lives at https://github.com/sparklemotion/sqlite3-ruby) may include the source code for `sqlite` (which lives at https://www.sqlite.org/)
-
-`sqlite` source code is licensed under the public domain:
-
-> https://www.sqlite.org/copyright.html
-
-The license terms shipped with `sqlite` are included here for your convenience:
-
-```
-The author disclaims copyright to this source code.  In place of
-a legal notice, here is a blessing:
-
-    May you do good and not evil.
-    May you find forgiveness for yourself and forgive others.
-    May you share freely, never taking more than you give.
-```
-
-Note that these license terms do not apply to the `sqlite3-ruby` library itself.

data/faq/faq.rb

@@ -1,145 +0,0 @@
-require 'yaml'
-require 'redcloth'
-
-def process_faq_list( faqs )
-  puts "<ul>"
-  faqs.each do |faq|
-    process_faq_list_item faq
-  end
-  puts "</ul>"
-end
-
-def process_faq_list_item( faq )
-  question = faq.keys.first
-  answer = faq.values.first
-
-  print "<li>"
-
-  question_text = RedCloth.new(question).to_html.gsub( %r{</?p>},"" )
-  if answer.is_a?( Array )
-    puts question_text
-    process_faq_list answer
-  else
-    print "<a href='##{question.object_id}'>#{question_text}</a>"
-  end
-
-  puts "</li>"
-end
-
-def process_faq_descriptions( faqs, path=nil )
-  faqs.each do |faq|
-    process_faq_description faq, path
-  end
-end
-
-def process_faq_description( faq, path )
-  question = faq.keys.first
-  path = ( path ? path + " " : "" ) + question
-  answer = faq.values.first
-
-  if answer.is_a?( Array )
-    process_faq_descriptions( answer, path )
-  else
-    title = RedCloth.new( path ).to_html.gsub( %r{</?p>}, "" )
-    answer = RedCloth.new( answer || "" )
-
-    puts "<a name='#{question.object_id}'></a>"
-    puts "<div class='faq-title'>#{title}</div>"
-    puts "<div class='faq-answer'>#{add_api_links(answer.to_html)}</div>"
-  end
-end
-
-API_OBJECTS = [ "Database", "Statement", "ResultSet",
-  "ParsedStatement", "Pragmas", "Translator" ].inject( "(" ) { |acc,name|
-    acc << "|" if acc.length > 1
-    acc << name
-    acc
-  } + ")"
-
-def add_api_links( text )
-  text.gsub( /#{API_OBJECTS}(#(\w+))?/ ) do
-    disp_obj = obj = $1
-
-    case obj
-      when "Pragmas"; disp_obj = "Database"
-    end
-
-    method = $3
-    s = "<a href='http://sqlite-ruby.rubyforge.org/classes/SQLite/#{obj}.html'>#{disp_obj}"
-    s << "##{method}" if method
-    s << "</a>"
-    s
-  end
-end
-
-faqs = YAML.load( File.read( "faq.yml" ) )
-
-puts <<-EOF
-<html>
-  <head>
-    <title>SQLite3/Ruby FAQ</title>
-    <style type="text/css">
-      a, a:visited, a:active {
-        color: #00F;
-        text-decoration: none;
-      }
-
-      a:hover {
-        text-decoration: underline;
-      }
-
-      .faq-list {
-        color: #000;
-        font-family: vera-sans, verdana, arial, sans-serif;
-      }
-
-      .faq-title {
-        background: #007;
-        color: #FFF;
-        font-family: vera-sans, verdana, arial, sans-serif;
-        padding-left: 1em;
-        padding-top: 0.5em;
-        padding-bottom: 0.5em;
-        font-weight: bold;
-        font-size: large;
-        border: 1px solid #000;
-      }
-
-      .faq-answer {
-        margin-left: 1em;
-        color: #000;
-        font-family: vera-sans, verdana, arial, sans-serif;
-      }
-
-      .faq-answer pre {
-        margin-left: 1em;
-        color: #000;
-        background: #FFE;
-        font-size: normal;
-        border: 1px dotted #CCC;
-        padding: 1em;
-      }
-
-      h1 {
-        background: #005;
-        color: #FFF;
-        font-family: vera-sans, verdana, arial, sans-serif;
-        padding-left: 1em;
-        padding-top: 1em;
-        padding-bottom: 1em;
-        font-weight: bold;
-        font-size: x-large;
-        border: 1px solid #00F;
-      }
-    </style>
-  </head>
-  <body>
-  <h1>SQLite/Ruby FAQ</h1>
-  <div class="faq-list">
-EOF
-
-process_faq_list( faqs )
-puts "</div>"
-process_faq_descriptions( faqs )
-
-puts "</body></html>"

data/faq/faq.yml

@@ -1,426 +0,0 @@
----
-- "How do I do a database query?":
-  - "I just want an array of the rows...": >-
-
-      Use the Database#execute method. If you don't give it a block, it will
-      return an array of all the rows:
-
-
-      <pre>
-        require 'sqlite3'
-
-        db = SQLite3::Database.new( "test.db" )
-        rows = db.execute( "select * from test" )
-      </pre>
-
-  - "I'd like to use a block to iterate through the rows...": >-
-
-      Use the Database#execute method. If you give it a block, each row of the
-      result will be yielded to the block:
-
-
-      <pre>
-        require 'sqlite3'
-
-        db = SQLite3::Database.new( "test.db" )
-        db.execute( "select * from test" ) do |row|
-          ...
-        end
-      </pre>
-
-  - "I need to get the column names as well as the rows...": >-
-
-      Use the Database#execute2 method. This works just like Database#execute;
-      if you don't give it a block, it returns an array of rows; otherwise, it
-      will yield each row to the block. _However_, the first row returned is
-      always an array of the column names from the query:
-
-
-      <pre>
-        require 'sqlite3'
-
-        db = SQLite3::Database.new( "test.db" )
-        columns, *rows = db.execute2( "select * from test" )
-
-        # or use a block:
-
-        columns = nil
-        db.execute2( "select * from test" ) do |row|
-          if columns.nil?
-            columns = row
-          else
-            # process row
-          end
-        end
-      </pre>
-
-  - "I just want the first row of the result set...": >-
-
-      Easy. Just call Database#get_first_row:
-
-
-      <pre>
-        row = db.get_first_row( "select * from table" )
-      </pre>
-
-
-      This also supports bind variables, just like Database#execute
-      and friends.
-
-  - "I just want the first value of the first row of the result set...": >-
-
-      Also easy. Just call Database#get_first_value:
-
-
-      <pre>
-        count = db.get_first_value( "select count(*) from table" )
-      </pre>
-
-
-      This also supports bind variables, just like Database#execute
-      and friends.
-
-- "How do I prepare a statement for repeated execution?": >-
-    If the same statement is going to be executed repeatedly, you can speed
-    things up a bit by _preparing_ the statement. You do this via the
-    Database#prepare method. It returns a Statement object, and you can
-    then invoke #execute on that to get the ResultSet:
-
-    
-    <pre>
-      stmt = db.prepare( "select * from person" )
-
-      1000.times do
-        stmt.execute do |result|
-          ...
-        end
-      end
-
-      stmt.close
-
-      # or, use a block
-
-      db.prepare( "select * from person" ) do |stmt|
-        1000.times do
-          stmt.execute do |result|
-            ...
-          end
-        end
-      end
-    </pre>
-
-
-    This is made more useful by the ability to bind variables to placeholders
-    via the Statement#bind_param and Statement#bind_params methods. (See the
-    next FAQ for details.)
-
-- "How do I use placeholders in an SQL statement?": >-
-    Placeholders in an SQL statement take any of the following formats:
-
-
-    * @?@
-
-    * @?_nnn_@
-
-    * @:_word_@
-
-
-    Where _n_ is an integer, and _word_ is an alpha-numeric identifier (or
-    number). When the placeholder is associated with a number, that number
-    identifies the index of the bind variable to replace it with. When it
-    is an identifier, it identifies the name of the corresponding bind
-    variable. (In the instance of the first format--a single question
-    mark--the placeholder is assigned a number one greater than the last
-    index used, or 1 if it is the first.)
-
-
-    For example, here is a query using these placeholder formats:
-
-
-    <pre>
-      select *
-        from table
-       where ( c = ?2 or c = ? )
-         and d = :name
-         and e = :1
-    </pre>
-
-
-    This defines 5 different placeholders: 1, 2, 3, and "name".
-
-
-    You replace these placeholders by _binding_ them to values. This can be
-    accomplished in a variety of ways.
-
-
-    The Database#execute, and Database#execute2 methods all accept additional
-    arguments following the SQL statement. These arguments are assumed to be
-    bind parameters, and they are bound (positionally) to their corresponding
-    placeholders:
-
-
-    <pre>
-      db.execute( "select * from table where a = ? and b = ?",
-                  "hello",
-                  "world" )
-    </pre>
-
-
-    The above would replace the first question mark with 'hello' and the
-    second with 'world'. If the placeholders have an explicit index given, they
-    will be replaced with the bind parameter at that index (1-based).
-
-
-    If a Hash is given as a bind parameter, then its key/value pairs are bound
-    to the placeholders. This is how you bind by name:
-
-
-    <pre>
-      db.execute( "select * from table where a = :name and b = :value",
-                  "name" => "bob",
-                  "value" => "priceless" )
-    </pre>
-
-
-    You can also bind explicitly using the Statement object itself. Just pass
-    additional parameters to the Statement#execute statement:
-    
-
-    <pre>
-      db.prepare( "select * from table where a = :name and b = ?" ) do |stmt|
-        stmt.execute "value", "name" => "bob"
-      end
-    </pre>
-
-
-    Or do a Database#prepare to get the Statement, and then use either
-    Statement#bind_param or Statement#bind_params:
-
-
-    <pre>
-      stmt = db.prepare( "select * from table where a = :name and b = ?" )
-
-      stmt.bind_param( "name", "bob" )
-      stmt.bind_param( 1, "value" )
-
-      # or
-
-      stmt.bind_params( "value", "name" => "bob" )
-    </pre>
-
-- "How do I discover metadata about a query?": >-
-  
-    If you ever want to know the names or types of the columns in a result
-    set, you can do it in several ways.
-
-
-    The first way is to ask the row object itself. Each row will have a
-    property "fields" that returns an array of the column names. The row
-    will also have a property "types" that returns an array of the column
-    types:
-
-
-    <pre>
-      rows = db.execute( "select * from table" )
-      p rows[0].fields
-      p rows[0].types
-    </pre>
-
-
-    Obviously, this approach requires you to execute a statement that actually
-    returns data. If you don't know if the statement will return any rows, but
-    you still need the metadata, you can use Database#query and ask the
-    ResultSet object itself:
-
-
-    <pre>
-      db.query( "select * from table" ) do |result|
-        p result.columns
-        p result.types
-        ...
-      end
-    </pre>
-
-
-    Lastly, you can use Database#prepare and ask the Statement object what
-    the metadata are:
-
-
-    <pre>
-      stmt = db.prepare( "select * from table" )
-      p stmt.columns
-      p stmt.types
-    </pre>
-
-- "I'd like the rows to be indexible by column name.": >-
-    By default, each row from a query is returned as an Array of values. This
-    means that you can only obtain values by their index. Sometimes, however,
-    you would like to obtain values by their column name.
-
-
-    The first way to do this is to set the Database property "results_as_hash"
-    to true. If you do this, then all rows will be returned as Hash objects,
-    with the column names as the keys. (In this case, the "fields" property
-    is unavailable on the row, although the "types" property remains.)
-
-
-    <pre>
-      db.results_as_hash = true
-      db.execute( "select * from table" ) do |row|
-        p row['column1']
-        p row['column2']
-      end
-    </pre>
-
-
-    The other way is to use Ara Howard's
-    "ArrayFields":http://rubyforge.org/projects/arrayfields
-    module. Just require "arrayfields", and all of your rows will be indexable
-    by column name, even though they are still arrays!
-
-
-    <pre>
-      require 'arrayfields'
-
-      ...
-      db.execute( "select * from table" ) do |row|
-        p row[0] == row['column1']
-        p row[1] == row['column2']
-      end
-    </pre>
-
-- "I'd like the values from a query to be the correct types, instead of String.": >-
-    You can turn on "type translation" by setting Database#type_translation to
-    true:
-
-
-    <pre>
-      db.type_translation = true
-      db.execute( "select * from table" ) do |row|
-        p row
-      end
-    </pre>
-
-
-    By doing this, each return value for each row will be translated to its
-    correct type, based on its declared column type.
-
-
-    You can even declare your own translation routines, if (for example) you are
-    using an SQL type that is not handled by default:
-
-
-    <pre>
-      # assume "objects" table has the following schema:
-      #   create table objects (
-      #     name varchar2(20),
-      #     thing object
-      #   )
-
-      db.type_translation = true
-      db.translator.add_translator( "object" ) do |type, value|
-        db.decode( value )
-      end
-
-      h = { :one=>:two, "three"=>"four", 5=>6 }
-      dump = db.encode( h )
-
-      db.execute( "insert into objects values ( ?, ? )", "bob", dump )
-
-      obj = db.get_first_value( "select thing from objects where name='bob'" )
-      p obj == h
-    </pre>
-
-- "How do I insert binary data into the database?": >-
-    Use blobs. Blobs are new features of SQLite3. You have to use bind
-    variables to make it work:
-
-
-    <pre>
-      db.execute( "insert into foo ( ?, ? )",
-        SQLite3::Blob.new( "\0\1\2\3\4\5" ),
-        SQLite3::Blob.new( "a\0b\0c\0d ) )
-    </pre>
-
-
-    The blob values must be indicated explicitly by binding each parameter to
-    a value of type SQLite3::Blob.
-
-- "How do I do a DDL (insert, update, delete) statement?": >-
-    You can actually do inserts, updates, and deletes in exactly the same way
-    as selects, but in general the Database#execute method will be most
-    convenient:
-
-    
-    <pre>
-      db.execute( "insert into table values ( ?, ? )", *bind_vars )
-    </pre>
-
-- "How do I execute multiple statements in a single string?": >-
-    The standard query methods (Database#execute, Database#execute2,
-    Database#query, and Statement#execute) will only execute the first
-    statement in the string that is given to them. Thus, if you have a
-    string with multiple SQL statements, each separated by a string,
-    you can't use those methods to execute them all at once.
-
-
-    Instead, use Database#execute_batch:
-
-
-    <pre>
-      sql = <<SQL
-        create table the_table (
-          a varchar2(30),
-          b varchar2(30)
-        );
-
-        insert into the_table values ( 'one', 'two' );
-        insert into the_table values ( 'three', 'four' );
-        insert into the_table values ( 'five', 'six' );
-      SQL
-
-      db.execute_batch( sql )
-    </pre>
-
-
-    Unlike the other query methods, Database#execute_batch accepts no
-    block. It will also only ever return +nil+. Thus, it is really only
-    suitable for batch processing of DDL statements.
-
-- "How do I begin/end a transaction?":
-    Use Database#transaction to start a transaction. If you give it a block,
-    the block will be automatically committed at the end of the block,
-    unless an exception was raised, in which case the transaction will be
-    rolled back. (Never explicitly call Database#commit or Database#rollback
-    inside of a transaction block--you'll get errors when the block
-    terminates!)
-
-
-    <pre>
-      database.transaction do |db|
-        db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-        ...
-      end
-    </pre>
-
-
-    Alternatively, if you don't give a block to Database#transaction, the
-    transaction remains open until you explicitly call Database#commit or
-    Database#rollback.
-
-
-    <pre>
-      db.transaction
-      db.execute( "insert into table values ( 'a', 'b', 'c' )" )
-      db.commit
-    </pre>
-
-
-    Note that SQLite does not allow nested transactions, so you'll get errors
-    if you try to open a new transaction while one is already active. Use
-    Database#transaction_active? to determine whether a transaction is
-    active or not.
-
-#- "How do I discover metadata about a table/index?":
-#
-#- "How do I do tweak database settings?":