Class: DuckDB::Result

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/duckdb/result.rb,
ext/duckdb/result.c

Overview

The Result class encapsulates a execute result of DuckDB database.

The usage is as follows:

require 'duckdb'

db = DuckDB::Database.open # database in memory
con = db.connect

con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')

con.execute("INSERT into users VALUES(1, 'Alice')")
con.execute("INSERT into users VALUES(2, 'Bob')")
con.execute("INSERT into users VALUES(3, 'Cathy')")

result = con.execute('SELECT * from users')
result.each do |row|
  p row
end

Constant Summary collapse

RETURN_TYPES = 
i[invalid changed_rows nothing query_result].freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.new ⇒ Object

Raises:



32
33
34
 
# File 'lib/duckdb/result.rb', line 32

def new
  raise DuckDB::Error, 'DuckDB::Result cannot be instantiated directly.'
end

Instance Method Details

#column_count ⇒ Integer Also known as: column_size

Returns the column size of the result.

DuckDB::Database.open do |db|
  db.connect do |con|
    r = con.query('CREATE TABLE t2 (id INT, name VARCHAR(128))')
    r = con.query("INSERT INTO t2 VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Catherine')")
    r = con.query('SELECT id FROM t2')
    r.column_count # => 1
    r = con.query('SELECT id, name FROM t2')
    r.column_count # => 2
  end
end

Returns:

  • (Integer) 


145
146
147
148
149
 
# File 'ext/duckdb/result.c', line 145

static VALUE duckdb_result_column_count(VALUE oDuckDBResult) {
    rubyDuckDBResult *ctx;
    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
    return LL2NUM(duckdb_column_count(&(ctx->result)));
}

#columns ⇒ DuckDB::Column[]

Returns the column class Lists.

Returns:



158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'ext/duckdb/result.c', line 158

static VALUE duckdb_result_columns(VALUE oDuckDBResult) {
    rubyDuckDBResult *ctx;
    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);

    idx_t col_idx;
    idx_t column_count = duckdb_column_count(&(ctx->result));

    VALUE ary = rb_ary_new2(column_count);
    for(col_idx = 0; col_idx < column_count; col_idx++) {
        VALUE column = rbduckdb_create_column(oDuckDBResult, col_idx);
        rb_ary_store(ary, col_idx, column);
    }
    return ary;
}

#each ⇒ Object 



37
38
39
40
41
 
# File 'lib/duckdb/result.rb', line 37

def each(&)
  return _chunk_stream unless block_given?

  _chunk_stream(&)
end

#enum_dictionary_values(col_index) ⇒ Object

returns all available ENUM type values of the specified column index.

require 'duckdb'
db = DuckDB::Database.open('duckdb_database')
con = db.connect
con.execute("CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy', 'π˜ΎπΎΦ…Ι­ 😎')")
con.execute("CREATE TABLE enums (id INTEGER, mood mood)")
result = con.query('SELECT * FROM enums')
result.enum_dictionary_values(1) # => ['sad', 'ok', 'happy', 'π˜ΎπΎΦ…Ι­ 😎']



82
83
84
85
86
87
88
 
# File 'lib/duckdb/result.rb', line 82

def enum_dictionary_values(col_index)
  values = []
  _enum_dictionary_size(col_index).times do |i|
    values << _enum_dictionary_value(col_index, i)
  end
  values
end

#return_type ⇒ Object

returns return type. The return value is one of the following symbols:

:invalid, :changed_rows, :nothing, :query_result

 require 'duckdb'
 db = DuckDB::Database.open('duckdb_database')
 con = db.connect
 result = con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
 result.return_type # => :nothing

Raises:



51
52
53
54
55
56
 
# File 'lib/duckdb/result.rb', line 51

def return_type
  i = _return_type
  raise DuckDB::Error, "Unknown return type: #{i}" if i >= RETURN_TYPES.size

  RETURN_TYPES[i]
end

#rows_changed ⇒ Integer

Returns the count of rows changed.

DuckDB::Database.open do |db|
  db.connect do |con|
    r = con.query('CREATE TABLE t2 (id INT)')
    r.rows_changed # => 0
    r = con.query('INSERT INTO t2 VALUES (1), (2), (3)')
    r.rows_changed # => 3
    r = con.query('UPDATE t2 SET id = id + 1 WHERE id > 1')
    r.rows_changed # => 2
    r = con.query('DELETE FROM t2 WHERE id = 0')
    r.rows_changed # => 0
    r = con.query('DELETE FROM t2 WHERE id = 4')
    r.rows_changed # => 1
  end
end

Returns:

  • (Integer) 


121
122
123
124
125
 
# File 'ext/duckdb/result.c', line 121

static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
    rubyDuckDBResult *ctx;
    TypedData_Get_Struct(oDuckDBResult, rubyDuckDBResult, &result_data_type, ctx);
    return LL2NUM(duckdb_rows_changed(&(ctx->result)));
}

#statement_type ⇒ Object

returns statement type. The return value is one of the following symbols:

:invalid, :select, :insert, :update, :explain, :delete, :prepare, :create,
:execute, :alter, :transaction, :copy, :analyze, :variable_set, :create_func,
:drop, :export, :pragma, :vacuum, :call, :set, :load, :relation, :extension,
:logical_plan, :attach, :detach, :multi

 require 'duckdb'
 db = DuckDB::Database.open('duckdb_database')
 con = db.connect
 result = con.execute('CREATE TABLE users (id INTEGER, name VARCHAR(30))')
 result.statement_type # => :create



69
70
71
72
 
# File 'lib/duckdb/result.rb', line 69

def statement_type
  i = _statement_type
  Converter::IntToSym.statement_type_to_sym(i)
end