class DuckDB::LogicalType

rubocop:disable Metrics/ClassLength

def create_array(type, size)

array_type.size #=> 3
array_type.child_type.type #=> :integer
array_type.type #=> :array
array_type = DuckDB::LogicalType.create_array(:integer, 3)

require 'duckdb'

The +size+ argument specifies the fixed size of the array.
The +type+ argument can be a symbol or a DuckDB::LogicalType instance.

Creates an array logical type with the given child type and size.

def create_array(type, size)
  _create_array_type(LogicalType.resolve(type), size)
end

def create_decimal(width, scale)

decimal_type.scale #=> 3
decimal_type.width #=> 18
decimal_type.type #=> :decimal
decimal_type = DuckDB::LogicalType.create_decimal(18, 3)

require 'duckdb'

Creates a decimal logical type with the given width and scale.

def create_decimal(width, scale)
  raise DuckDB::Error, 'width must be between 1 and 38' unless Converter::RANGE_DECIMAL_WIDTH.cover?(width)
  raise DuckDB::Error, "scale must be between 0 and width(#{width})" unless (0..width).cover?(scale)
  _create_decimal_type(width, scale)
end

def create_enum(*members)

enum_type.dictionary_value_at(0) #=> "happy"
enum_type.dictionary_size #=> 3
enum_type.type #=> :enum
enum_type = DuckDB::LogicalType.create_enum('happy', 'sad', 'neutral')

require 'duckdb'

Each member must be a String representing an enum member.

Creates an enum logical type with the given members.

def create_enum(*members)
  _create_enum_type(members.map(&:to_s))
end

def create_list(type)

nested_list.child_type.type #=> :list
nested_list = DuckDB::LogicalType.create_list(list_type)

list_type.child_type.type #=> :integer
list_type.type #=> :list
list_type = DuckDB::LogicalType.create_list(:integer)

require 'duckdb'

The +type+ argument can be a symbol or a DuckDB::LogicalType instance.

Creates a list logical type with the given child type.

def create_list(type)
  _create_list_type(LogicalType.resolve(type))
end

def create_map(key_type, value_type)

map_type.value_type.type #=> :varchar
map_type.key_type.type #=> :integer
map_type.type #=> :map
map_type = DuckDB::LogicalType.create_map(:integer, :varchar)

require 'duckdb'

DuckDB::LogicalType instances.
The +key_type+ and +value_type+ arguments can be symbols or

Creates a map logical type with the given key and value types.

def create_map(key_type, value_type)
  _create_map_type(LogicalType.resolve(key_type), LogicalType.resolve(value_type))
end

def create_struct(**members)

struct_type.child_type_at(0).type #=> :varchar
struct_type.child_name_at(0) #=> "name"
struct_type.child_count #=> 2
struct_type.type #=> :struct
struct_type = DuckDB::LogicalType.create_struct(name: :varchar, age: :integer)

require 'duckdb'

a symbol or a DuckDB::LogicalType instance.
The keyword arguments map member names to types. Each type can be

Creates a struct logical type with the given member names and types.

def create_struct(**members)
  resolved = members.transform_values { |v| LogicalType.resolve(v) }
  _create_struct_type(resolved)
end

def create_union(**members)

union_type.member_type_at(0).type #=> :integer
union_type.member_name_at(0) #=> "num"
union_type.member_count #=> 2
union_type.type #=> :union
union_type = DuckDB::LogicalType.create_union(num: :integer, str: :varchar)

require 'duckdb'

a symbol or a DuckDB::LogicalType instance.
The keyword arguments map member names to types. Each type can be

Creates a union logical type with the given member names and types.

def create_union(**members)
  resolved = members.transform_values { |v| LogicalType.resolve(v) }
  _create_union_type(resolved)
end

def each_child_name

# => ["child1", "child2"]
names = struct_logical_type.each_child_name.to_a

retrieve all child names.
If no block is given, an Enumerator is returned, which can be used to

end
puts "Struct child: #{name}"
struct_logical_type.each_child_name do |name|

order. It also returns the total number of children yielded.
When a block is provided, this method yields each struct child name in

Iterates over each struct child name.

def each_child_name
  return to_enum(__method__) { child_count } unless block_given?
  child_count.times do |i|
    yield child_name_at(i)
  end
end

def each_child_type

# => [:integer, :varchar]
types = struct_logical_type.each_child_type.map(&:type)

retrieve all child logical types.
If no block is given, an Enumerator is returned, which can be used to

end
puts "Struct child type: #{logical_type.type}"
struct_logical_type.each_child_type do |logical_type|

order. It also returns the total number of children yielded.
When a block is provided, this method yields each struct child type in

Iterates over each struct child type.

def each_child_type
  return to_enum(__method__) { child_count } unless block_given?
  child_count.times do |i|
    yield child_type_at(i)
  end
end

def each_dictionary_value

# => ["happy", "sad"]
values = enum_logical_type.each_value.to_a

retrieve all enum dictionary values.
If no block is given, an Enumerator is returned, which can be used to

end
puts "Enum value: #{value}"
enum_logical_type.each_value do |value|

in order. It also returns the total number of dictionary values yielded.
When a block is provided, this method yields each enum dictionary value

Iterates over each enum dictionary value.

def each_dictionary_value
  return to_enum(__method__) { dictionary_size } unless block_given?
  dictionary_size.times do |i|
    yield dictionary_value_at(i)
  end
end

def each_member_name

# => ["member1", "member2"]
names = union_logical_type.each_member_name.to_a

retrieve all member names.
If no block is given, an Enumerator is returned, which can be used to

end
puts "Union member: #{name}"
union_logical_type.each_member_name do |name|

order. It also returns the total number of members yielded.
When a block is provided, this method yields each union member name in

Iterates over each union member name.

def each_member_name
  return to_enum(__method__) { member_count } unless block_given?
  member_count.times do |i|
    yield member_name_at(i)
  end
end

def each_member_type

# => [:varchar, :integer]
names = union_logical_type.each_member_type.map(&:type)

retrieve all member logical types.
If no block is given, an Enumerator is returned, which can be used to

end
puts "Union member: #{logical_type.type}"
union_logical_type.each_member_type do |logical_type|

type in order. It also returns the total number of members yielded.
When a block is provided, this method yields each union member logical

Iterates over each union member type.

def each_member_type
  return to_enum(__method__) { member_count } unless block_given?
  member_count.times do |i|
    yield member_type_at(i)
  end
end

def inspect

:nodoc:

def inspect
  "<#{self.class}::#{type.upcase}>"
end

def internal_type

enum_col.logical_type.internal_type #=> :utinyint
ernum_col = users.columns.find { |col| col.name == 'enum_col' }
users = con.query('SELECT * FROM emotions')

con.query("CREATE TABLE emotions (id INTEGER, enum_col mood)")
con.query("CREATE TYPE mood AS ENUM ('happy', 'sad')")
con = db.connect
db = DuckDB::Database.open
require 'duckdb'

`:invalid` means that the logical type's type is invalid in duckdb.
`:unknown` means that the logical type's type is unknown/unsupported by ruby-duckdb.
returns logical type's internal type symbol for Decimal or Enum types

def internal_type
  type_id = _internal_type
  DuckDB::Converter::IntToSym.type_to_sym(type_id)
end

def raise_resolve_error(symbol)

def raise_resolve_error(symbol)
  raise DuckDB::Error, "Unknown logical type: `#{symbol.inspect}`"
end

def resolve(symbol)

def resolve(symbol)
  return symbol if symbol.is_a?(DuckDB::LogicalType)
  raise_resolve_error(symbol) unless symbol.respond_to?(:upcase)
  DuckDB::LogicalType.const_get(symbol.upcase)
rescue NameError
  raise_resolve_error(symbol)
end

def to_s