class SQLite3::ResultSet

obtain a ResultSet instance via Statement#execute.
very rarely (if ever) be instantiated directly. Instead, client’s should
It is a simple cursor over the data that the query returns. It will
The ResultSet object encapsulates the enumerability of a query’s output.

def check(result)

def check(result)
  @eof = (result == Constants::ErrorCode::DONE)
  found = (result == Constants::ErrorCode::ROW)
  Error.check(result, @db) unless @eof || found
end

def close

close any other result sets that were spawned from the same statement.
Use with caution! Closing a result set will automatically
Closes the statement that spawned this result set.

def close
  @stmt.close
end

def closed?

Queries whether the underlying statement has been closed or not.

def closed?
  @stmt.closed?
end

def columns

Returns the names of the columns returned by this result set.

def columns
  @stmt.columns
end

def commence

to the first row of the result set.
A convenience method for compiling the virtual machine and stepping

def commence
  result = @driver.step(@stmt.handle)
  if result == Constants::ErrorCode::ERROR
    @driver.reset(@stmt.handle)
  end
  check result
  @first_row = true
end

def each

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

def each
  while row=self.next
    yield row
  end
end

def eof?

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

def eof?
  @eof
end

def initialize(db, stmt)

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

def initialize(db, stmt)
  @db = db
  @driver = @db.driver
  @stmt = stmt
  commence
end

def next

types are accessible via the +types+ property.
For hashes, the column names are the keys of the hash, and the column

and the column types are accessible via the +types+ property.
For arrays, the column names are accessible via the +fields+ property,

been set to +true+, in which case the returned value will be a hash.
The returned value will be an array, unless Database#results_as_hash has

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

def next
  return nil if @eof
  @stmt.must_be_open!
  unless @first_row
    result = @driver.step(@stmt.handle)
    check result
  end
  @first_row = false
  unless @eof
    row = []
    @driver.data_count(@stmt.handle).times do |column|
      type  = @driver.column_type(@stmt.handle, column)
      if type == Constants::ColumnType::TEXT
        row << @driver.column_text(@stmt.handle, column)
      elsif type == Constants::ColumnType::NULL
        row << nil
      elsif type == Constants::ColumnType::BLOB
        row << @driver.column_blob(@stmt.handle, column)
      else
        row << @driver.column_text(@stmt.handle, column)
      end
    end
    if @db.type_translation
      row = @stmt.types.zip(row).map do |type, value|
        @db.translator.translate(type, value)
      end
    end
    if @db.results_as_hash
      new_row = HashWithTypes[ *(@stmt.columns.zip(row).to_a.flatten) ]
      row.each_with_index { |value,idx| new_row[idx] = value }
      row = new_row
    else
      if row.respond_to?(:fields)
        row = ArrayWithTypes.new(row)
      else
        row = ArrayWithTypesAndFields.new(row)
      end
      row.fields = @stmt.columns
    end
    row.types = @stmt.types
    return row
  end
  nil
end

def reset(*bind_params)

can be rewound and reiterated.
Reset the cursor, so that a result set which has reached end-of-file

def reset(*bind_params)
  @stmt.must_be_open!
  @stmt.reset!(false)
  @driver.reset(@stmt.handle)
  @stmt.bind_params(*bind_params)
  @eof = false
  commence
end

def types

Returns the types of the columns returned by this result set.

def types
  @stmt.types
end

Modules

Classes