duckdb 1.5.2.1 → 1.5.4.0

data/lib/duckdb/appender.rb

@@ -7,6 +7,11 @@ require_relative 'converter'
 module DuckDB
   # The DuckDB::Appender encapsulates DuckDB Appender.
   #
+  # The +table+ argument (2nd positional argument) supports dot-notation and quoting:
+  #
+  # - <tt>'schema.table'</tt> — interpreted as schema-qualified (deprecated; use +schema:+ instead)
+  # - <tt>'"schema.table"'</tt> or <tt>"'schema.table'"</tt> — treated as a literal table name containing a dot
+  #
   #   require 'duckdb'
   #   db = DuckDB::Database.open
   #   con = db.connect
@@ -15,11 +20,21 @@ module DuckDB
   #   appender.append_row(1, 'Alice')
   class Appender
     include DuckDB::Converter
+    include DuckDB::TableNameParser
 
     class << self
       alias from_query create_query
     end
 
+    def initialize(con, table_or_schema, table = nil, schema: nil, catalog: nil)
+      if table
+        warn_deprecated_3arg
+        _initialize(con, table_or_schema, table)
+      else
+        initialize_with_parsed_table(con, table_or_schema, schema: schema, catalog: catalog)
+      end
+    end
+
     # :call-seq:
     #   appender.begin_row -> self
     # A nop method, provided for backwards compatibility reasons.
@@ -543,6 +558,29 @@ module DuckDB
       raise_appender_error('failed to append_uhugeint')
     end
 
+    # :call-seq:
+    #   appender.append_uuid(val) -> self
+    #
+    # Appends a UUID value to the current row in the appender.
+    # +val+ must be a String in canonical UUID format
+    # (<tt>xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</tt>).
+    # Raises ArgumentError if +val+ is not a valid UUID string.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE uuids (id UUID)')
+    #   appender = con.appender('uuids')
+    #   appender
+    #     .append_uuid('550e8400-e29b-41d4-a716-446655440000')
+    #     .end_row
+    #     .flush
+    def append_uuid(value)
+      return self if _append_uuid(value)
+
+      raise_appender_error('failed to append_uuid')
+    end
+
     # call-seq:
     #   appender.append_date(val) -> self
     #
@@ -661,6 +699,20 @@ module DuckDB
 
     # call-seq:
     #   appender.append_data_chunk(chunk) -> self
+    #
+    # Appends a pre-filled DuckDB::DataChunk to the appender.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+    #   appender = con.appender('users')
+    #   chunk = DuckDB::DataChunk.new([DuckDB::LogicalType::INTEGER, DuckDB::LogicalType::VARCHAR])
+    #   chunk.set_value(0, 0, 1)
+    #   chunk.set_value(1, 0, 'Alice')
+    #   chunk.size = 1
+    #   appender.append_data_chunk(chunk)
+    #   appender.flush
     def append_data_chunk(chunk)
       raise ArgumentError, "expected DuckDB::DataChunk, got #{chunk.class}" unless chunk.is_a?(DuckDB::DataChunk)
 
@@ -669,6 +721,34 @@ module DuckDB
       raise_appender_error('failed to append_data_chunk')
     end
 
+    # call-seq:
+    #   appender.append_default_to_chunk(chunk, col, row) -> self
+    #
+    # Appends the DEFAULT value for the column at +col+ and +row+ in +chunk+.
+    # If no DEFAULT is defined for the column, NULL is used.
+    # Call this before appending the chunk via #append_data_chunk.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (name VARCHAR, enabled BOOLEAN DEFAULT TRUE)')
+    #   appender = con.appender('users')
+    #   chunk = DuckDB::DataChunk.new([DuckDB::LogicalType::VARCHAR, DuckDB::LogicalType::BOOLEAN])
+    #   appender.append_default_to_chunk(chunk, 1, 0)  # enabled DEFAULT for row 0
+    #   appender.append_default_to_chunk(chunk, 1, 1)  # enabled DEFAULT for row 1
+    #   chunk.set_value(0, 0, 'Alice')
+    #   chunk.set_value(0, 1, 'Bob')
+    #   chunk.size = 2
+    #   appender.append_data_chunk(chunk)
+    #   appender.flush
+    def append_default_to_chunk(chunk, col, row)
+      raise ArgumentError, "expected DuckDB::DataChunk, got #{chunk.class}" unless chunk.is_a?(DuckDB::DataChunk)
+
+      return self if _append_default_to_chunk(chunk, col, row)
+
+      raise_appender_error('failed to append_default_to_chunk')
+    end
+
     # appends value.
     #
     #   require 'duckdb'
@@ -722,6 +802,23 @@ module DuckDB
 
     private
 
+    def warn_deprecated_3arg # :nodoc:
+      warn(
+        'DuckDB::Appender.new(con, schema, table) is deprecated. ' \
+        'Use DuckDB::Appender.new(con, table, schema: schema) instead.',
+        category: :deprecated
+      )
+    end
+
+    def initialize_with_parsed_table(con, table_name, schema:, catalog:) # :nodoc:
+      table_name, schema, catalog = parse_table_name(table_name, schema, catalog)
+      if catalog
+        _initialize_ext(con, catalog, schema, table_name)
+      else
+        _initialize(con, schema, table_name)
+      end
+    end
+
     def raise_appender_error(default_message) # :nodoc:
       message = error_message
       raise DuckDB::Error, message || default_message

data/lib/duckdb/arrow_array_stream.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # The ArrowArrayStream class represents an exported Arrow C stream of a
+  # query result (Arrow C Data Interface). It is created by
+  # DuckDB::Result#arrow_c_stream and cannot be instantiated directly.
+  #
+  # The object satisfies the Ruby Arrow C stream protocol: #arrow_c_stream
+  # returns self and #to_i returns the address of the underlying
+  # <tt>struct ArrowArrayStream</tt>, so it can be consumed by ruby-polars,
+  # red-arrow and other Arrow consumers:
+  #
+  #   result = con.query('SELECT * FROM users')
+  #
+  #   # ruby-polars
+  #   df = Polars::DataFrame.new(result)
+  #
+  #   # red-arrow
+  #   reader = Arrow::RecordBatchReader.import(result.arrow_c_stream.to_i)
+  #
+  # The consumer takes ownership of the stream's contents; a result can be
+  # exported only once.
+  #
+  # [EXPERIMENTAL] This API is built on DuckDB's unstable Arrow C API and
+  # may change in any minor release.
+  class ArrowArrayStream
+    class << self
+      def new
+        raise DuckDB::Error, 'DuckDB::ArrowArrayStream cannot be instantiated directly. Use DuckDB::Result#arrow_c_stream.'
+      end
+    end
+  end
+end

data/lib/duckdb/connection.rb

@@ -8,6 +8,8 @@ module DuckDB
   #   con = db.connect
   #   con.query(sql)
   class Connection
+    include DuckDB::TableNameParser
+
     # executes sql with args.
     # The first argument sql must be SQL string.
     # The rest arguments are parameters of SQL string.
@@ -127,11 +129,43 @@ module DuckDB
       PreparedStatement.prepare(self, str, &)
     end
 
-    # returns Appender object.
-    # The first argument is table name
-    def appender(table, &)
-      appender = create_appender(table)
-      run_appender_block(appender, &)
+    # :call-seq:
+    #   connection.appender(table, schema: nil, catalog: nil) -> DuckDB::Appender
+    #   connection.appender(table, schema: nil, catalog: nil) { |appender| ... } -> self
+    #
+    # Returns a DuckDB::Appender for bulk-inserting rows into +table+.
+    # If a block is given, the appender is flushed and closed automatically after the block.
+    #
+    # +schema:+ and +catalog:+ optionally qualify the table.
+    #
+    # Raises DuckDB::Error if the table (or schema/catalog) does not exist.
+    #
+    # Table name parsing (quoting, dot-notation) is handled by DuckDB::Appender.new.
+    # See DuckDB::Appender.new for details on quoting and dot-notation.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE users (id INTEGER, name VARCHAR)')
+    #
+    #   # block form (recommended) — flushes and closes automatically
+    #   con.appender('users') do |a|
+    #     a.append_row(1, 'Alice')
+    #     a.append_row(2, 'Bob')
+    #   end
+    #
+    #   # with schema
+    #   con.appender('users', schema: 'main') do |a|
+    #     a.append_row(3, 'Carol')
+    #   end
+    #
+    #   # manual form
+    #   appender = con.appender('users')
+    #   appender.append_row(4, 'Dave')
+    #   appender.close
+    def appender(table, schema: nil, catalog: nil, &)
+      table, schema, catalog = parse_connection_appender_table(table, schema, catalog)
+      run_appender_block(Appender.new(self, table, schema: schema, catalog: catalog), &)
     end
 
     if Appender.respond_to?(:create_query)
@@ -234,7 +268,7 @@ module DuckDB
     # allowing DuckDB to dispatch to the correct implementation based on argument types.
     #
     # @param scalar_function_set [DuckDB::ScalarFunctionSet] the function set to register
-    # @return [void]
+    # @return [self]
     # @raise [TypeError] if argument is not a DuckDB::ScalarFunctionSet
     #
     # @example Register multiple overloads under one name
@@ -251,6 +285,42 @@ module DuckDB
       _register_scalar_function_set(scalar_function_set)
     end
 
+    # Registers an aggregate function set with the connection.
+    # An aggregate function set groups multiple overloads of an aggregate function under one name,
+    # allowing DuckDB to dispatch to the correct implementation based on argument types.
+    #
+    # @param aggregate_function_set [DuckDB::AggregateFunctionSet] the function set to register
+    # @return [self]
+    # @raise [TypeError] if argument is not a DuckDB::AggregateFunctionSet
+    #
+    # @example Register multiple overloads under one name
+    #   af_bigint = DuckDB::AggregateFunction.new
+    #   af_bigint.name = 'my_sum'
+    #   af_bigint.return_type = DuckDB::LogicalType::BIGINT
+    #   af_bigint.add_parameter(DuckDB::LogicalType::BIGINT)
+    #   af_bigint.set_init   { 0 }
+    #   af_bigint.set_update  { |state, val| state + val }
+    #   af_bigint.set_combine { |s1, s2| s1 + s2 }
+    #
+    #   af_double = DuckDB::AggregateFunction.new
+    #   af_double.name = 'my_sum'
+    #   af_double.return_type = DuckDB::LogicalType::DOUBLE
+    #   af_double.add_parameter(DuckDB::LogicalType::DOUBLE)
+    #   af_double.set_init   { 0.0 }
+    #   af_double.set_update  { |state, val| state + val }
+    #   af_double.set_combine { |s1, s2| s1 + s2 }
+    #
+    #   set = DuckDB::AggregateFunctionSet.new(:my_sum)
+    #   set.add(af_bigint).add(af_double)
+    #   con.register_aggregate_function_set(set)
+    def register_aggregate_function_set(aggregate_function_set)
+      unless aggregate_function_set.is_a?(AggregateFunctionSet)
+        raise TypeError, "#{aggregate_function_set.class} is not a DuckDB::AggregateFunctionSet"
+      end
+
+      _register_aggregate_function_set(aggregate_function_set)
+    end
+
     # Registers an aggregate function with the connection.
     #
     # @param aggregate_function [DuckDB::AggregateFunction] the aggregate function to register
@@ -313,8 +383,62 @@ module DuckDB
       register_table_function(tf)
     end
 
+    # [EXPERIMENTAL] Appends an Arrow producer into an existing table.
+    #
+    # Reads +producer+ (any object responding to +#arrow_c_stream+, such as a
+    # ruby-polars +DataFrame+ or a +DuckDB::Result+) as an Arrow C stream and
+    # appends its chunks into the existing table +table+. The producer's Arrow
+    # columns must line up with the table's columns positionally and by count.
+    # DuckDB casts compatible column types (e.g. INTEGER into a BIGINT column);
+    # a type that cannot be cast (e.g. a non-numeric VARCHAR into an INTEGER
+    # column) or a column-count mismatch raises +DuckDB::Error+.
+    #
+    # This is not transactional: a schema mismatch fails before any rows are
+    # written, but a rarer mid-stream failure can leave earlier chunks
+    # appended. Wrap the call in your own transaction for all-or-nothing.
+    #
+    # This API is built on DuckDB's unstable Arrow C API and may change in any
+    # minor release.
+    #
+    # @param table [String] the name of the existing target table
+    # @param producer [#arrow_c_stream] the Arrow producer
+    # @raise [TypeError] if +producer+ does not respond to +#arrow_c_stream+
+    # @return [Integer] the number of rows appended
+    #
+    # @example Load a Polars DataFrame into a table
+    #   con.query('CREATE TABLE t (id INTEGER, name VARCHAR)')
+    #   con.append_arrow('t', polars_df)
+    #
+    def append_arrow(table, producer)
+      unless producer.respond_to?(:arrow_c_stream)
+        raise TypeError, "Arrow producer must respond to #arrow_c_stream, got #{producer.class}"
+      end
+
+      stream = producer.arrow_c_stream # keep the producer's stream alive for the duration
+      address = stream.to_i
+      begin
+        append_arrow_chunks(table, address)
+      ensure
+        _arrow_release(address)
+      end
+    end
+
     private
 
+    # Drives the Arrow stream at +address+ chunk by chunk into +table+,
+    # returning the number of rows appended.
+    def append_arrow_chunks(table, address)
+      converted_schema = _arrow_converted_schema(address)
+      rows = 0
+      appender(table) do |app|
+        while (chunk = _arrow_next_chunk(address, converted_schema))
+          rows += chunk.size
+          app.append_data_chunk(chunk)
+        end
+      end
+      rows
+    end
+
     def run_appender_block(appender, &)
       return appender unless block_given?
 
@@ -323,9 +447,15 @@ module DuckDB
       appender.close
     end
 
-    def create_appender(table)
-      t1, t2 = table.split('.')
-      t2 ? Appender.new(self, t1, t2) : Appender.new(self, t2, t1)
+    # Silently pre-parses dot-notation so Appender.new receives clean values
+    # and does not emit a misleading "DuckDB::Appender.new" warning.
+    # con.appender('a.b') has always split on dot — no warning needed.
+    # Quoted table names pass through unchanged for Appender.new to handle.
+    def parse_connection_appender_table(table, schema, catalog)
+      return [table, schema, catalog] if quoted_table_name?(table)
+      return [table, schema, catalog] unless table.include?('.')
+
+      dot_notation_split(table, schema, catalog)
     end
 
     alias execute query

data/lib/duckdb/prepared_statement.rb

@@ -193,6 +193,23 @@ module DuckDB
       _bind_uhugeint(index, lower, upper)
     end
 
+    # binds i-th parameter with a UUID value.
+    # The first argument is the index of the parameter (1-based).
+    # The second argument must be a String in canonical UUID format
+    # (<tt>xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</tt>).
+    # Raises ArgumentError if the value is not a valid UUID string.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open
+    #   con = db.connect
+    #   con.query('CREATE TABLE uuids (id UUID)')
+    #   stmt = DuckDB::PreparedStatement.new(con, 'INSERT INTO uuids(id) VALUES ($1)')
+    #   stmt.bind_uuid(1, '550e8400-e29b-41d4-a716-446655440000')
+    #   stmt.execute
+    def bind_uuid(index, value)
+      _bind_uuid(index, value)
+    end
+
     # binds i-th parameter with SQL prepared statement.
     # The first argument is index of parameter.
     # The index of first parameter is 1 not 0.
@@ -250,6 +267,24 @@ module DuckDB
       _bind_timestamp(index, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
     end
 
+    # binds i-th parameter of TIMESTAMP WITH TIME ZONE (TIMESTAMPTZ) type with SQL prepared statement.
+    # The first argument is index of parameter.
+    # The index of first parameter is 1 not 0.
+    # The second argument value is to expected time value.
+    #
+    #   require 'duckdb'
+    #   db = DuckDB::Database.open('duckdb_database')
+    #   con = db.connect
+    #   sql ='SELECT name FROM users WHERE created_at = ?'
+    #   stmt = PreparedStatement.new(con, sql)
+    #   stmt.bind_timestamp_tz(1, Time.now)
+    #   #  or you can specify timestamp string.
+    #   # stmt.bind_timestamp_tz(1, '2022-02-23 07:39:45+00')
+    def bind_timestamp_tz(index, value)
+      time = _parse_time(value).utc
+      _bind_timestamp_tz(index, time.year, time.month, time.day, time.hour, time.min, time.sec, time.usec)
+    end
+
     # binds i-th parameter with SQL prepared statement.
     # The first argument is index of parameter.
     # The index of first parameter is 1 not 0.

data/lib/duckdb/result.rb

@@ -81,11 +81,48 @@ module DuckDB
     #   result = con.query('SELECT * FROM enums')
     #   result.enum_dictionary_values(1) # => ['sad', 'ok', 'happy', '𝘾𝝾օɭ 😎']
     def enum_dictionary_values(col_index)
+      column = columns[col_index]
+
+      raise ArgumentError, "Invalid index: #{col_index}" if column.nil? || col_index.negative?
+
+      lt = column.logical_type
+
+      raise DuckDB::Error, "Column[#{col_index}] type is not enum" if lt.type != :enum
+
       values = []
-      _enum_dictionary_size(col_index).times do |i|
-        values << _enum_dictionary_value(col_index, i)
+      lt.dictionary_size.times do |i|
+        values << lt.dictionary_value_at(i)
       end
       values
     end
+
+    private
+
+    def _enum_dictionary_size(idx)
+      warn(":_enum_dictionary_size is deprecated. use columns[#{idx}].logical_type.dictionary_size instead.")
+
+      raise ArgumentError, "Invalid index: #{idx}" if idx.negative?
+
+      columns[idx]&.logical_type&.dictionary_size
+    end
+
+    def _enum_dictionary_value(col_index, idx)
+      warn(":_enum_dictionary_value is deprecated.\
+           use columns[#{col_index}].logical_type.dictionary_value_at(#{idx}) instead.")
+
+      raise ArgumentError, "Invalid index: #{col_index}" if col_index.negative?
+
+      lt = columns[col_index]&.logical_type
+
+      raise DuckDB::Error, "Column[#{col_index}] type is not enum" if lt&.type != :enum
+
+      lt.dictionary_value_at(idx)
+    end
+
+    def _column_type(idx)
+      warn(":_column_type is deprecated. use columns[#{idx}].send(:_type) instead.")
+
+      columns[idx].send(:_type)
+    end
   end
 end

data/lib/duckdb/scalar_function.rb

@@ -7,8 +7,7 @@ module DuckDB
   class ScalarFunction
     # Create and configure a scalar function in one call
     #
-    # @param name [String, Symbol, nil] the function name; use +nil+ when creating overloads
-    #   intended for use in a +DuckDB::ScalarFunctionSet+ (the set provides the name)
+    # @param name [String, Symbol] the function name (required)
     # @param return_type [DuckDB::LogicalType|:logical_type_symbol] the return type
     # @param parameter_type [DuckDB::LogicalType|:logical_type_symbol, nil] single fixed parameter type
     # @param parameter_types [Array<DuckDB::LogicalType|:logical_type_symbol>, nil] multiple fixed parameter types
@@ -64,7 +63,7 @@ module DuckDB
     #     null_handling: true
     #   ) { |v| v.nil? ? 0 : v }
     def self.create( # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/ParameterLists
-      return_type:, name: nil, parameter_type: nil, parameter_types: nil, varargs_type: nil, null_handling: false, &
+      name:, return_type:, parameter_type: nil, parameter_types: nil, varargs_type: nil, null_handling: false, &
     )
       raise ArgumentError, 'Block required' unless block_given?
       raise ArgumentError, 'Cannot specify both parameter_type and parameter_types' if parameter_type && parameter_types
@@ -78,7 +77,7 @@ module DuckDB
                end
 
       sf = new
-      sf.name = name.to_s if name
+      sf.name = name
       sf.return_type = return_type
       params.each { |type| sf.add_parameter(type) }
       sf.varargs_type = varargs_type if varargs_type
@@ -87,6 +86,12 @@ module DuckDB
       sf
     end
 
+    def name=(value)
+      set_name(value.to_s)
+    end
+
+    private :set_name
+
     include FunctionTypeValidation
 
     # Adds a parameter to the scalar function.

data/lib/duckdb/scalar_function_set.rb

@@ -24,7 +24,6 @@ module DuckDB
         raise TypeError, "#{scalar_function.class} is not a DuckDB::ScalarFunction"
       end
 
-      scalar_function.name = @name
       _add(scalar_function)
     end
   end

data/lib/duckdb/table_description.rb

@@ -21,11 +21,17 @@ module DuckDB
     #   # id: integer, default=false
     #   # name: varchar, default=true
     class TableDescription
+      include DuckDB::TableNameParser
+
       # Creates a new TableDescription for the given table.
       #
       # +con+ must be a DuckDB::Connection. +table+ is the table name (String).
       # Optionally pass +schema:+ and/or +catalog:+ to qualify the table.
       #
+      # The +table+ argument supports dot-notation and quoting:
+      # - <tt>'schema.table'</tt> — interpreted as schema-qualified (deprecated; use +schema:+ instead)
+      # - <tt>'"a.b"'</tt> or <tt>"'a.b'"</tt> — treated as a literal table name containing a dot
+      #
       # Raises DuckDB::Error if the connection is invalid, the table name is nil,
       # or the table (or schema/catalog) does not exist.
       #
@@ -40,6 +46,7 @@ module DuckDB
         raise DuckDB::Error, '1st argument must be DuckDB::Connection object.' unless con.is_a?(DuckDB::Connection)
         raise DuckDB::Error, '2nd argument must be table name.' if table.nil?
 
+        table, schema, catalog = parse_table_name(table, schema, catalog)
         raise DuckDB::Error, error_message unless _initialize(con, catalog, schema, table)
       end
 

data/lib/duckdb/table_name_parser.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module DuckDB
+  # DuckDB::TableNameParser provides shared table name parsing for classes that
+  # accept a table name argument, such as DuckDB::Appender and DuckDB::TableDescription.
+  #
+  # It handles:
+  # - Dot-notation: <tt>'schema.table'</tt> is split into schema and table (deprecated).
+  # - Quoting: <tt>'"a.b"'</tt> or <tt>"'a.b'"</tt> strips the quotes and treats the name literally.
+  module TableNameParser
+    private
+
+    # Parses +table+, +schema+, and +catalog+, handling quoting and dot-notation.
+    # Returns <tt>[table, schema, catalog]</tt>.
+    def parse_table_name(table, schema, catalog)
+      if quoted_table_name?(table)
+        [unquote_table_name(table), schema, catalog]
+      elsif table.include?('.')
+        warn_dot_notation_deprecated(table)
+        dot_notation_split(table, schema, catalog)
+      else
+        [table, schema, catalog]
+      end
+    end
+
+    def quoted_table_name?(name) # :nodoc:
+      name.match?(/\A(["']).*\1\z/)
+    end
+
+    def unquote_table_name(name) # :nodoc:
+      name[1..-2]
+    end
+
+    # Splits a dot-notation string into [table, schema, catalog].
+    # Explicit keyword args take precedence over dot-notation parts.
+    def dot_notation_split(table, schema, catalog) # :nodoc:
+      parts = table.split('.')
+      raise ArgumentError, "Too many dot-separated segments in '#{table}'" if parts.length > 3
+
+      case parts.length
+      when 2 then [parts[1], schema || parts[0], catalog]
+      when 3 then [parts[2], schema || parts[1], catalog || parts[0]]
+      else raise ArgumentError, "Unexpected segment count in '#{table}'"
+      end
+    end
+
+    def warn_dot_notation_deprecated(table) # :nodoc:
+      class_name = self.class.name
+      warn(
+        "Passing dot-notation '#{table}' to #{class_name}.new is deprecated. " \
+        "If '#{table}' is a schema-qualified table, use #{class_name}.new(con, table, schema: schema) instead. " \
+        "If '#{table}' is a literal table name containing a dot, " \
+        "use #{class_name}.new(con, '\"#{table}\"') instead.",
+        category: :deprecated
+      )
+    end
+  end
+end

data/lib/duckdb/version.rb

@@ -3,5 +3,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '1.5.2.1'
+  VERSION = '1.5.4.0'
 end

data/lib/duckdb.rb

@@ -4,10 +4,12 @@ require 'duckdb/duckdb_native'
 require 'duckdb/library_version'
 require 'duckdb/version'
 require 'duckdb/converter'
+require 'duckdb/table_name_parser'
 require 'duckdb/database'
 require 'duckdb/connection'
 require 'duckdb/extracted_statements'
 require 'duckdb/result'
+require 'duckdb/arrow_array_stream'
 require 'duckdb/prepared_statement'
 require 'duckdb/pending_result'
 require 'duckdb/appender'
@@ -18,6 +20,7 @@ require 'duckdb/function_type_validation'
 require 'duckdb/scalar_function'
 require 'duckdb/scalar_function_set'
 require 'duckdb/aggregate_function'
+require 'duckdb/aggregate_function_set'
 require 'duckdb/expression'
 require 'duckdb/client_context'
 require 'duckdb/scalar_function/bind_info'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 1.5.2.1
+  version: 1.5.4.0
 platform: ruby
 authors:
 - Masaki Suketa
@@ -43,8 +43,14 @@ files:
 - duckdb.gemspec
 - ext/duckdb/aggregate_function.c
 - ext/duckdb/aggregate_function.h
+- ext/duckdb/aggregate_function_set.c
+- ext/duckdb/aggregate_function_set.h
 - ext/duckdb/appender.c
 - ext/duckdb/appender.h
+- ext/duckdb/arrow_array_stream.c
+- ext/duckdb/arrow_array_stream.h
+- ext/duckdb/arrow_import.c
+- ext/duckdb/arrow_import.h
 - ext/duckdb/blob.c
 - ext/duckdb/blob.h
 - ext/duckdb/client_context.c
@@ -110,7 +116,9 @@ files:
 - ext/duckdb/vector.h
 - lib/duckdb.rb
 - lib/duckdb/aggregate_function.rb
+- lib/duckdb/aggregate_function_set.rb
 - lib/duckdb/appender.rb
+- lib/duckdb/arrow_array_stream.rb
 - lib/duckdb/casting.rb
 - lib/duckdb/client_context.rb
 - lib/duckdb/column.rb
@@ -140,6 +148,7 @@ files:
 - lib/duckdb/table_function/bind_info.rb
 - lib/duckdb/table_function/function_info.rb
 - lib/duckdb/table_function/init_info.rb
+- lib/duckdb/table_name_parser.rb
 - lib/duckdb/value.rb
 - lib/duckdb/vector.rb
 - lib/duckdb/version.rb
@@ -165,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby bindings for the DuckDB database engine.
 test_files: []