sqlite3 2.0.0-x86_64-linux-gnu

data/lib/sqlite3/resultset.rb

@@ -0,0 +1,96 @@
+require "sqlite3/constants"
+require "sqlite3/errors"
+
+module SQLite3
+  # The ResultSet object encapsulates the enumerability of a query's output.
+  # It is a simple cursor over the data that the query returns. It will
+  # very rarely (if ever) be instantiated directly. Instead, clients should
+  # obtain a ResultSet instance via Statement#execute.
+  class ResultSet
+    include Enumerable
+
+    # Create a new ResultSet attached to the given database, using the
+    # given sql text.
+    def initialize db, stmt
+      @db = db
+      @stmt = stmt
+    end
+
+    # Reset the cursor, so that a result set which has reached end-of-file
+    # can be rewound and reiterated.
+    def reset(*bind_params)
+      @stmt.reset!
+      @stmt.bind_params(*bind_params)
+    end
+
+    # Query whether the cursor has reached the end of the result set or not.
+    def eof?
+      @stmt.done?
+    end
+
+    # Obtain the next row from the cursor. If there are no more rows to be
+    # had, this will return +nil+.
+    #
+    # The returned value will be an array, unless Database#results_as_hash has
+    # been set to +true+, in which case the returned value will be a hash.
+    #
+    # For arrays, the column names are accessible via the +fields+ property,
+    # and the column types are accessible via the +types+ property.
+    #
+    # For hashes, the column names are the keys of the hash, and the column
+    # types are accessible via the +types+ property.
+    def next
+      @stmt.step
+    end
+
+    # Required by the Enumerable mixin. Provides an internal iterator over the
+    # rows of the result set.
+    def each
+      while (node = self.next)
+        yield node
+      end
+    end
+
+    # Provides an internal iterator over the rows of the result set where
+    # each row is yielded as a hash.
+    def each_hash
+      while (node = next_hash)
+        yield node
+      end
+    end
+
+    # Closes the statement that spawned this result set.
+    # <em>Use with caution!</em> Closing a result set will automatically
+    # close any other result sets that were spawned from the same statement.
+    def close
+      @stmt.close
+    end
+
+    # Queries whether the underlying statement has been closed or not.
+    def closed?
+      @stmt.closed?
+    end
+
+    # Returns the types of the columns returned by this result set.
+    def types
+      @stmt.types
+    end
+
+    # Returns the names of the columns returned by this result set.
+    def columns
+      @stmt.columns
+    end
+
+    # Return the next row as a hash
+    def next_hash
+      row = @stmt.step
+      return nil if @stmt.done?
+
+      @stmt.columns.zip(row).to_h
+    end
+  end
+
+  class HashResultSet < ResultSet # :nodoc:
+    alias_method :next, :next_hash
+  end
+end

data/lib/sqlite3/statement.rb

@@ -0,0 +1,190 @@
+require "sqlite3/errors"
+require "sqlite3/resultset"
+
+class String
+  def to_blob
+    SQLite3::Blob.new(self)
+  end
+end
+
+module SQLite3
+  # A statement represents a prepared-but-unexecuted SQL query. It will rarely
+  # (if ever) be instantiated directly by a client, and is most often obtained
+  # via the Database#prepare method.
+  class Statement
+    include Enumerable
+
+    # This is any text that followed the first valid SQL statement in the text
+    # with which the statement was initialized. If there was no trailing text,
+    # this will be the empty string.
+    attr_reader :remainder
+
+    # call-seq: SQLite3::Statement.new(db, sql)
+    #
+    # Create a new statement attached to the given Database instance, and which
+    # encapsulates the given SQL text. If the text contains more than one
+    # statement (i.e., separated by semicolons), then the #remainder property
+    # will be set to the trailing text.
+    def initialize(db, sql)
+      raise ArgumentError, "prepare called on a closed database" if db.closed?
+
+      sql = sql.encode(Encoding::UTF_8) if sql && sql.encoding != Encoding::UTF_8
+
+      @connection = db
+      @columns = nil
+      @types = nil
+      @remainder = prepare db, sql
+    end
+
+    # Binds the given variables to the corresponding placeholders in the SQL
+    # text.
+    #
+    # See Database#execute for a description of the valid placeholder
+    # syntaxes.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table where a=? and b=?" )
+    #   stmt.bind_params( 15, "hello" )
+    #
+    # See also #execute, #bind_param, Statement#bind_param, and
+    # Statement#bind_params.
+    def bind_params(*bind_vars)
+      index = 1
+      bind_vars.flatten.each do |var|
+        if Hash === var
+          var.each { |key, val| bind_param key, val }
+        else
+          bind_param index, var
+          index += 1
+        end
+      end
+    end
+
+    # Execute the statement. This creates a new ResultSet object for the
+    # statement's virtual machine. If a block was given, the new ResultSet will
+    # be yielded to it; otherwise, the ResultSet will be returned.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute do |result|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute!.
+    def execute(*bind_vars)
+      reset! if active? || done?
+
+      bind_params(*bind_vars) unless bind_vars.empty?
+      results = @connection.build_result_set self
+
+      step if column_count == 0
+
+      yield results if block_given?
+      results
+    end
+
+    # Execute the statement. If no block was given, this returns an array of
+    # rows returned by executing the statement. Otherwise, each row will be
+    # yielded to the block.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute! do |row|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute.
+    def execute!(*bind_vars, &block)
+      execute(*bind_vars)
+      block ? each(&block) : to_a
+    end
+
+    # Returns true if the statement is currently active, meaning it has an
+    # open result set.
+    def active?
+      !done?
+    end
+
+    # Return an array of the column names for this statement. Note that this
+    # may execute the statement in order to obtain the metadata; this makes it
+    # a (potentially) expensive operation.
+    def columns
+      get_metadata unless @columns
+      @columns
+    end
+
+    def each
+      loop do
+        val = step
+        break self if done?
+        yield val
+      end
+    end
+
+    # Return an array of the data types for each column in this statement. Note
+    # that this may execute the statement in order to obtain the metadata; this
+    # makes it a (potentially) expensive operation.
+    def types
+      must_be_open!
+      get_metadata unless @types
+      @types
+    end
+
+    # Performs a sanity check to ensure that the statement is not
+    # closed. If it is, an exception is raised.
+    def must_be_open! # :nodoc:
+      if closed?
+        raise SQLite3::Exception, "cannot use a closed statement"
+      end
+    end
+
+    # Returns a Hash containing information about the statement.
+    # The contents of the hash are implementation specific and may change in
+    # the future without notice. The hash includes information about internal
+    # statistics about the statement such as:
+    #   - +fullscan_steps+: the number of times that SQLite has stepped forward
+    # in a table as part of a full table scan
+    #   - +sorts+: the number of sort operations that have occurred
+    #   - +autoindexes+: the number of rows inserted into transient indices
+    # that were created automatically in order to help joins run faster
+    #   - +vm_steps+: the number of virtual machine operations executed by the
+    # prepared statement
+    #   - +reprepares+: the number of times that the prepare statement has been
+    # automatically regenerated due to schema changes or changes to bound
+    # parameters that might affect the query plan
+    #   - +runs+: the number of times that the prepared statement has been run
+    #   - +filter_misses+: the number of times that the Bloom filter returned
+    # a find, and thus the join step had to be processed as normal
+    #   - +filter_hits+: the number of times that a join step was bypassed
+    # because a Bloom filter returned not-found
+    def stat key = nil
+      if key
+        stat_for(key)
+      else
+        stats_as_hash
+      end
+    end
+
+    private
+
+    # A convenience method for obtaining the metadata about the query. Note
+    # that this will actually execute the SQL, which means it can be a
+    # (potentially) expensive operation.
+    def get_metadata
+      @columns = Array.new(column_count) do |column|
+        column_name column
+      end
+      @types = Array.new(column_count) do |column|
+        val = column_decltype(column)
+        val&.downcase
+      end
+    end
+  end
+end

data/lib/sqlite3/value.rb

@@ -0,0 +1,54 @@
+require "sqlite3/constants"
+
+module SQLite3
+  class Value
+    attr_reader :handle
+
+    def initialize(db, handle)
+      @driver = db.driver
+      @handle = handle
+    end
+
+    def null?
+      type == :null
+    end
+
+    def to_blob
+      @driver.value_blob(@handle)
+    end
+
+    def length(utf16 = false)
+      if utf16
+        @driver.value_bytes16(@handle)
+      else
+        @driver.value_bytes(@handle)
+      end
+    end
+
+    def to_f
+      @driver.value_double(@handle)
+    end
+
+    def to_i
+      @driver.value_int(@handle)
+    end
+
+    def to_int64
+      @driver.value_int64(@handle)
+    end
+
+    def to_s(utf16 = false)
+      @driver.value_text(@handle, utf16)
+    end
+
+    def type
+      case @driver.value_type(@handle)
+      when Constants::ColumnType::INTEGER then :int
+      when Constants::ColumnType::FLOAT then :float
+      when Constants::ColumnType::TEXT then :text
+      when Constants::ColumnType::BLOB then :blob
+      when Constants::ColumnType::NULL then :null
+      end
+    end
+  end
+end

data/lib/sqlite3/version.rb

@@ -0,0 +1,3 @@
+module SQLite3
+  VERSION = "2.0.0"
+end

data/lib/sqlite3.rb

@@ -0,0 +1,17 @@
+# support multiple ruby version (fat binaries under windows)
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "sqlite3/#{$1}/sqlite3_native"
+rescue LoadError
+  require "sqlite3/sqlite3_native"
+end
+
+require "sqlite3/database"
+require "sqlite3/version"
+
+module SQLite3
+  # Was sqlite3 compiled with thread safety on?
+  def self.threadsafe?
+    threadsafe > 0
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: sqlite3
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: x86_64-linux-gnu
+authors:
+- Jamis Buck
+- Luis Lavena
+- Aaron Patterson
+- Mike Dalessio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-04-17 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Ruby library to interface with the SQLite3 database engine (http://www.sqlite.org). Precompiled
+  binaries are available for common platforms for recent versions of Ruby.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- README.md
+- ext/sqlite3/aggregator.c
+- ext/sqlite3/backup.c
+- ext/sqlite3/database.c
+- ext/sqlite3/exception.c
+- ext/sqlite3/sqlite3.c
+- ext/sqlite3/statement.c
+files:
+- ".gemtest"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- FAQ.md
+- INSTALLATION.md
+- LICENSE
+- README.md
+- dependencies.yml
+- ext/sqlite3/aggregator.c
+- ext/sqlite3/aggregator.h
+- ext/sqlite3/backup.c
+- ext/sqlite3/backup.h
+- ext/sqlite3/database.c
+- ext/sqlite3/database.h
+- ext/sqlite3/exception.c
+- ext/sqlite3/exception.h
+- ext/sqlite3/extconf.rb
+- ext/sqlite3/sqlite3.c
+- ext/sqlite3/sqlite3_ruby.h
+- ext/sqlite3/statement.c
+- ext/sqlite3/statement.h
+- ext/sqlite3/timespec.h
+- lib/sqlite3.rb
+- lib/sqlite3/3.0/sqlite3_native.so
+- lib/sqlite3/3.1/sqlite3_native.so
+- lib/sqlite3/3.2/sqlite3_native.so
+- lib/sqlite3/3.3/sqlite3_native.so
+- lib/sqlite3/constants.rb
+- lib/sqlite3/database.rb
+- lib/sqlite3/errors.rb
+- lib/sqlite3/pragmas.rb
+- lib/sqlite3/resultset.rb
+- lib/sqlite3/statement.rb
+- lib/sqlite3/value.rb
+- lib/sqlite3/version.rb
+homepage: https://github.com/sparklemotion/sqlite3-ruby
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/sparklemotion/sqlite3-ruby
+  bug_tracker_uri: https://github.com/sparklemotion/sqlite3-ruby/issues
+  documentation_uri: https://www.rubydoc.info/gems/sqlite3
+  changelog_uri: https://github.com/sparklemotion/sqlite3-ruby/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/sparklemotion/sqlite3-ruby
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.4.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Ruby library to interface with the SQLite3 database engine (http://www.sqlite.org).
+test_files: []