Class: SQLite::ResultSet

### Home Classes Methods

### In Files

- lib/sqlite/resultset.rb

### Parent

Object

### Namespace

- MODULE SQLite::ResultSet::FieldsContainer
- MODULE SQLite::ResultSet::TypesContainer

### Methods

- ::new
- #close
- #each
- #eof?
- #next
- #reset

### Included Modules

- Enumerable

### Files

- README

### Class/Module Index

Quicksearch

- SQLite
- SQLite::API
- SQLite::Database
- SQLite::Database::FunctionProxy
- SQLite::Exceptions
- SQLite::Exceptions::AbortException
- SQLite::Exceptions::AuthorizationException
- SQLite::Exceptions::BusyException
- SQLite::Exceptions::CantOpenException
- SQLite::Exceptions::ConstraintException
- SQLite::Exceptions::CorruptException
- SQLite::Exceptions::DatabaseException
- SQLite::Exceptions::EmptyException
- SQLite::Exceptions::FormatException
- SQLite::Exceptions::FullException
- SQLite::Exceptions::IOErrorException
- SQLite::Exceptions::InternalException
- SQLite::Exceptions::InterruptException
- SQLite::Exceptions::LockedException
- SQLite::Exceptions::MismatchException
- SQLite::Exceptions::MisuseException
- SQLite::Exceptions::NotADatabaseException
- SQLite::Exceptions::NotFoundException
- SQLite::Exceptions::OutOfMemoryException
- SQLite::Exceptions::PermissionsException
- SQLite::Exceptions::ProtocolException
- SQLite::Exceptions::RangeException
- SQLite::Exceptions::ReadOnlyException
- SQLite::Exceptions::SQLException
- SQLite::Exceptions::SchemaChangedException
- SQLite::Exceptions::TooBigException
- SQLite::Exceptions::UnsupportedOSFeatureException
- SQLite::ParsedStatement
- SQLite::Pragmas
- SQLite::ResultSet
- SQLite::ResultSet::FieldsContainer
- SQLite::ResultSet::TypesContainer
- SQLite::Statement
- SQLite::Translator
- SQLite::Version

No matching classes.

# SQLite::ResultSet

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, client's should obtain a ResultSet instance via Statement#execute.

### Attributes

columns[R]

An array of the column names for this result set (may be empty)

types[R]

An array of the column types for this result set (may be empty)

### Public Class Methods

new( db, sql ) click to toggle source

Create a new ResultSet attached to the given database, using the given sql text.

    # File lib/sqlite/resultset.rb, line 62
    def initialize( db, sql )
      @db = db
      @sql = sql
      commence
    end

### Public Instance Methods

close() click to toggle source

Close the result set. Attempting to perform any operation (including close) on a closed result set will have undefined results.

    # File lib/sqlite/resultset.rb, line 90
    def close
      API.finalize( @vm )
    end

each() click to toggle source

Required by the Enumerable mixin. Provides an internal iterator over the rows of the result set.

    # File lib/sqlite/resultset.rb, line 160
    def each
      while row=self.next
        yield row
      end
    end

eof?() click to toggle source

Query whether the cursor has reached the end of the result set or not.

    # File lib/sqlite/resultset.rb, line 104
    def eof?
      @eof
    end

next() click to toggle source

Obtain the next row from the cursor. If there are no more rows to be had, this will return `nil`. If type translation is active on the corresponding database, the values in the row will be translated according to their types.

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.

    # File lib/sqlite/resultset.rb, line 121
    def next
      return nil if @eof

      if @current_row
        result, @current_row = @current_row, nil
      else
        result = API.step( @vm )
        check_eof( result )
      end

      unless @eof
        row = result[:row]

        if @db.type_translation
          row = @types.zip( row ).map do |type, value|
            @db.translator.translate( type, value )
          end
        end

        if @db.results_as_hash
          new_row = Hash[ *( @columns.zip( row ).flatten ) ]
          row.each_with_index { |value,idx| new_row[idx] = value }
          row = new_row
        else
          row.extend FieldsContainer unless row.respond_to?(:fields)
          row.fields = @columns
        end

        row.extend TypesContainer
        row.types = @types

        return row
      end

      nil
    end

reset() click to toggle source

Reset the cursor, so that a result set which has reached end-of-file can be rewound and reiterated. Note: this uses an experimental API, which is subject to change. Use at your own risk.

    # File lib/sqlite/resultset.rb, line 97
    def reset
      API.finalize( @vm )
      commence
      @eof = false
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.