chdb-ruby 0.1.0.rc.2

data/ext/chdb/extconf.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'mkmf'
+require 'yaml'
+require 'open-uri'
+
+module ChDB
+  module ExtConf
+    class << self
+      def configure
+        configure_cross_compiler
+
+        download_and_extract
+
+        configure_extension
+
+        create_makefile('chdb/chdb_native')
+      end
+
+      def compiled?
+        return false if cross_build?
+
+        major_version = RUBY_VERSION.match(/(\d+\.\d+)/)[1]
+        version_dir = File.join(package_root_dir, 'lib', 'chdb', major_version)
+
+        extension = if determine_target_platform.include?('darwin')
+                      'bundle'
+                    else
+                      'so'
+                    end
+        lib_file = "#{libname}.#{extension}"
+
+        File.exist?(File.join(version_dir, lib_file))
+      end
+
+      def configure_cross_compiler
+        RbConfig::CONFIG['CC'] = RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+        ENV['CC'] = RbConfig::CONFIG['CC']
+      end
+
+      def cross_build?
+        enable_config('cross-build')
+      end
+
+      def libname
+        'chdb_native'
+      end
+
+      def configure_extension
+        include_path = File.expand_path('ext/chdb/include', package_root_dir)
+        append_cppflags("-I#{include_path}")
+        abort_could_not_find('chdb.h') unless find_header('chdb.h', include_path)
+      end
+
+      def abort_could_not_find(missing)
+        message = <<~MSG
+          Could not find #{missing}.
+          Please visit https://github.com/chdb-io/chdb-ruby for installation instructions.
+        MSG
+        abort("\n#{message}\n")
+      end
+
+      def download_and_extract
+        target_platform = determine_target_platform
+        version = fetch_chdb_version
+        download_dir = determine_download_directory(target_platform, version)
+        need_download = false
+
+        if Dir.exist?(download_dir)
+          required_files = [
+            File.join(download_dir, 'chdb.h'),
+            File.join(download_dir, 'libchdb.so')
+          ]
+
+          need_download = !required_files.all? { |f| File.exist?(f) }
+          if need_download
+            puts 'Missing required files, cleaning download directory...'
+            FileUtils.rm_rf(Dir.glob("#{download_dir}/*"))
+          end
+        else
+          FileUtils.mkdir_p(download_dir)
+          need_download = true
+        end
+
+        if need_download
+          file_name = get_file_name(target_platform)
+          url = build_download_url(version, file_name)
+          download_tarball(url, download_dir, file_name)
+          extract_tarball(download_dir, file_name)
+        end
+
+        copy_files(download_dir, version)
+      end
+
+      private
+
+      def determine_target_platform
+        return ENV['TARGET'].strip if ENV['TARGET'] && !ENV['TARGET'].strip.empty?
+
+        case RUBY_PLATFORM
+        when /aarch64-linux/ then 'aarch64-linux'
+        when /x86_64-linux/  then 'x86_64-linux'
+        when /arm64-darwin/  then 'arm64-darwin'
+        when /x86_64-darwin/ then 'x86_64-darwin'
+        else
+          raise ArgumentError, "Unsupported platform: #{RUBY_PLATFORM}."
+        end
+      end
+
+      def fetch_chdb_version
+        dependencies = YAML.load_file(File.join(package_root_dir, 'dependencies.yml'), symbolize_names: true)
+        dependencies[:chdb][:version]
+      end
+
+      def determine_download_directory(target_platform, version)
+        File.join(package_root_dir, 'deps', version, target_platform)
+      end
+
+      def get_file_name(target_platform)
+        case target_platform
+        when 'aarch64-linux' then 'linux-aarch64-libchdb.tar.gz'
+        when 'x86_64-linux' then 'linux-x86_64-libchdb.tar.gz'
+        when 'arm64-darwin'     then 'macos-arm64-libchdb.tar.gz'
+        when 'x86_64-darwin'    then 'macos-x86_64-libchdb.tar.gz'
+        else raise "Unsupported platform: #{target_platform}"
+        end
+      end
+
+      def build_download_url(version, file_name)
+        "https://github.com/chdb-io/chdb/releases/download/v#{version}/#{file_name}"
+      end
+
+      def download_tarball(url, download_dir, file_name)
+        tarball = File.join(download_dir, file_name)
+        puts "Downloading chdb library for #{determine_target_platform}..."
+
+        max_retries = 3
+        retries = 0
+
+        begin
+          URI.open(url) do |remote| # rubocop:disable Security/Open
+            IO.copy_stream(remote, tarball)
+          end
+        rescue StandardError => e
+          raise "Failed to download after #{max_retries} attempts: #{e.message}" unless retries < max_retries
+
+          retries += 1
+          puts "Download failed: #{e.message}. Retrying (attempt #{retries}/#{max_retries})..."
+          retry
+        end
+      end
+
+      def extract_tarball(download_dir, file_name)
+        tarball = File.join(download_dir, file_name)
+        system("tar xzf #{tarball} -C #{download_dir}")
+      end
+
+      def copy_files(download_dir, _version)
+        [%w[*.h], %w[*.so]].each do |(glob_pattern)|
+          # Removed the unused variable src_dir
+          pattern = File.basename(glob_pattern)
+          dest_subdir = case pattern
+                        when '*.h' then 'include'
+                        else 'lib'
+                        end
+          dest_dir = File.join(package_root_dir, 'ext/chdb', dest_subdir)
+          src_files = Dir.glob(File.join(download_dir, pattern))
+
+          extra_dirs = []
+          extra_dirs << File.join(package_root_dir, 'lib/chdb/lib') if pattern == '*.so'
+
+          ([dest_dir] + extra_dirs).each do |dest|
+            FileUtils.mkdir_p(dest)
+
+            src_files.each do |src_file|
+              dest_file = File.join(dest, File.basename(src_file))
+              FileUtils.ln_s(File.expand_path(src_file), dest_file, force: true)
+            end
+          end
+        end
+      end
+
+      def package_root_dir
+        File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+      end
+    end
+  end
+end
+
+if arg_config('--download-dependencies')
+  ChDB::ExtConf.download_and_extract
+  exit!(0)
+end
+
+ChDB::ExtConf.configure

data/ext/chdb/local_result.c

@@ -0,0 +1,81 @@
+#include "local_result.h"
+
+#include "constants.h"
+#include "include/chdb.h"
+
+VALUE cLocalResult;
+
+static void local_result_free(void *ptr)
+{
+    LocalResult *result = (LocalResult *)ptr;
+    DEBUG_PRINT("Freeing LocalResult: %p", (void*)result);
+    if (result->c_result)
+    {
+        free_result_v2(result->c_result);
+    }
+    free(result);
+}
+
+const rb_data_type_t LocalResultType =
+{
+    "LocalResult",
+    {NULL, local_result_free, NULL},
+};
+
+void init_local_result()
+{
+    VALUE mChDB = rb_define_module("ChDB");
+    cLocalResult = rb_define_class_under(mChDB, "LocalResult", rb_cObject);
+    rb_define_alloc_func(cLocalResult, local_result_alloc);
+    rb_define_method(cLocalResult, "buf", local_result_buf, 0);
+    rb_define_method(cLocalResult, "elapsed", local_result_elapsed, 0);
+    rb_define_method(cLocalResult, "rows_read", local_result_rows_read, 0);
+    rb_define_method(cLocalResult, "bytes_read", local_result_bytes_read, 0);
+}
+
+VALUE local_result_alloc(VALUE klass)
+{
+    LocalResult *result = ALLOC(LocalResult);
+    DEBUG_PRINT("Allocating LocalResult: %p", (void*)result);
+    result->c_result = NULL;
+    return rb_data_typed_object_wrap(klass, result, &LocalResultType);
+}
+
+VALUE local_result_buf(VALUE self)
+{
+    LocalResult *result;
+    TypedData_Get_Struct(self, LocalResult, &LocalResultType, result);
+
+    if (!result->c_result || !result->c_result->buf)
+    {
+        DEBUG_PRINT("Buffer access attempted on empty result");
+        return Qnil;
+    }
+
+    DEBUG_PRINT("Returning buffer of length %zu", result->c_result->len);
+    return rb_str_new(result->c_result->buf, result->c_result->len);
+}
+
+VALUE local_result_elapsed(VALUE self)
+{
+    LocalResult *result;
+    TypedData_Get_Struct(self, LocalResult, &LocalResultType, result);
+    DEBUG_PRINT("Query elapsed time: %f", result->c_result->elapsed);
+    return DBL2NUM(result->c_result->elapsed);
+}
+
+VALUE local_result_rows_read(VALUE self)
+{
+    LocalResult *result;
+    TypedData_Get_Struct(self, LocalResult, &LocalResultType, result);
+    DEBUG_PRINT("Rows read: %" PRIu64, result->c_result->rows_read);
+    return ULONG2NUM(result->c_result->rows_read);
+}
+
+VALUE local_result_bytes_read(VALUE self)
+{
+    LocalResult *result;
+    TypedData_Get_Struct(self, LocalResult, &LocalResultType, result);
+    DEBUG_PRINT("Bytes read: %" PRIu64, result->c_result->bytes_read);
+    return ULONG2NUM(result->c_result->bytes_read);
+}

data/ext/chdb/local_result.h

@@ -0,0 +1,26 @@
+#ifndef CHDB_LOCAL_RESULT_H
+#define CHDB_LOCAL_RESULT_H
+
+#include <ruby.h>
+
+typedef struct
+{
+    struct local_result_v2 *c_result;
+} LocalResult;
+
+extern VALUE cLocalResult;
+extern const rb_data_type_t LocalResultType;
+
+void init_local_result();
+
+VALUE local_result_alloc(VALUE klass);
+
+VALUE local_result_buf(VALUE self);
+
+VALUE local_result_elapsed(VALUE self);
+
+VALUE local_result_rows_read(VALUE self);
+
+VALUE local_result_bytes_read(VALUE self);
+
+#endif

data/lib/chdb/constants.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ChDB
+  module Constants
+  end
+end

data/lib/chdb/data_path.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'fileutils'
+require 'tempfile'
+require 'chdb/constants'
+require 'chdb/errors'
+
+module ChDB
+  # Represents the data path configuration for ChDB.
+  # This class is responsible for initializing and managing the data path
+  # including parsing URIs, handling query parameters, and ensuring directory existence.
+  class DataPath
+    attr_reader :dir_path, :is_tmp, :query_params, :mode
+
+    def initialize(uri, options)
+      initialize_instance_variables
+      path = parse_uri(uri)
+      merge_options(options)
+      check_params
+      directory_path(path)
+    end
+
+    def generate_arguments # rubocop:disable Metrics/MethodLength
+      args = ['clickhouse', "--path=#{@dir_path}"]
+      excluded_keys = %i[results_as_hash readonly readwrite flags]
+
+      @query_params.each do |key, value|
+        next if excluded_keys.include?(key)
+
+        case key.to_s
+        when 'udf_path'
+          udf_value = value.to_s
+          args += ['--', "--user_scripts_path=#{udf_value}",
+                   "--user_defined_executable_functions_config=#{udf_value}/*.xml"]
+          next
+        when '--'
+          args << '--'
+          next
+        end
+
+        key_str = key.to_s
+        args << if value.nil?
+                  "--#{key_str}"
+                else
+                  "--#{key_str}=#{value}"
+                end
+      end
+
+      args << '--readonly=1' if @mode.anybits?(Constants::Open::READONLY)
+
+      args
+    end
+
+    def close
+      FileUtils.remove_entry(@dir_path, true) if @is_tmp && Dir.exist?(@dir_path)
+    end
+
+    private
+
+    def initialize_instance_variables
+      @dir_path = nil
+      @is_tmp = false
+      @query_params = {}
+      @mode = 0
+    end
+
+    def parse_uri(uri)
+      path, query_str = uri.split('?', 2) unless uri.nil?
+      @query_params = CGI.parse(query_str.to_s).transform_values(&:last) unless query_str.nil?
+      remove_file_prefix(path)
+    end
+
+    def merge_options(options)
+      @query_params = @query_params.merge(options)
+      # @query_params = @query_params.merge(options.transform_keys(&:to_s))
+    end
+
+    def directory_path(path)
+      if path.nil? || path.empty? || path == ':memory:'
+        @is_tmp = true
+        @dir_path = Dir.mktmpdir('chdb_')
+      else
+        @dir_path = File.expand_path(path)
+        ensure_directory_exists
+      end
+    end
+
+    def ensure_directory_exists
+      if @mode.nobits?(Constants::Open::CREATE)
+        raise DirectoryNotFoundException, "Directory #{@dir_path} required" unless Dir.exist?(@dir_path)
+
+        return
+      end
+
+      FileUtils.mkdir_p(@dir_path, mode: 0o755)
+    end
+
+    def check_params # rubocop:disable Metrics/MethodLength
+      @mode = Constants::Open::READWRITE | Constants::Open::CREATE
+      @mode = Constants::Open::READONLY if @query_params[:readonly]
+
+      if @query_params[:readwrite]
+        raise InvalidArgumentException, 'conflicting options: readonly and readwrite' if @query_params[:readonly]
+
+        @mode = Constants::Open::READWRITE
+      end
+
+      return unless @query_params[:flags]
+      if @query_params[:readonly] || @query_params[:readwrite]
+        raise InvalidArgumentException, 'conflicting options: flags with readonly and/or readwrite'
+      end
+
+      @mode = @query_params[:flags]
+    end
+
+    def remove_file_prefix(str)
+      str.sub(/\Afile:/, '')
+    end
+  end
+end

data/lib/chdb/database.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "chdb/#{Regexp.last_match(1)}/chdb_native"
+rescue LoadError
+  require 'chdb/chdb_native'
+end
+require 'chdb/data_path'
+require 'chdb/statement'
+
+module ChDB
+  # Represents a database connection and provides methods to interact with the database.
+  class Database # rubocop:disable Metrics/ClassLength
+    class << self
+      # Without block works exactly as new.
+      # With block, like new closes the database at the end, but unlike new
+      # returns the result of the block instead of the database instance.
+      def open(*args)
+        database = new(*args)
+
+        if block_given?
+          begin
+            yield database
+          ensure
+            database.close
+          end
+        else
+          database
+        end
+      end
+    end
+
+    # A boolean that indicates whether rows in result sets should be returned
+    # as hashes or not. By default, rows are returned as arrays.
+    attr_accessor :results_as_hash, :conn
+
+    def initialize(file, options = {}) # rubocop:disable Metrics/MethodLength
+      file = file.to_path if file.respond_to? :to_path
+
+      @data_path = DataPath.new(file, options)
+      @results_as_hash = @data_path.query_params[:results_as_hash]
+      @readonly = @data_path.mode & Constants::Open::READONLY != 0
+
+      argv = @data_path.generate_arguments
+      @conn = ChDB::Connection.new(argv.size, argv)
+      @closed = false
+
+      return unless block_given?
+
+      begin
+        yield self
+      ensure
+        close
+      end
+    end
+
+    def close
+      return if defined?(@closed) && @closed
+
+      @data_path.close if @data_path.respond_to?(:close)
+      @conn.close if @conn.respond_to?(:close)
+      @closed = true
+    end
+
+    def closed?
+      defined?(@closed) && @closed
+    end
+
+    def prepare(sql)
+      stmt = ChDB::Statement.new(self, sql)
+      return stmt unless block_given?
+
+      yield stmt
+    end
+
+    def execute(sql, bind_vars = [], &block)
+      prepare(sql) do |stmt|
+        result = stmt.execute(bind_vars)
+
+        if block
+          result.each(&block)
+        else
+          result.to_a.freeze
+        end
+      end
+    end
+
+    def execute2(sql, *bind_vars, &) # rubocop:disable Metrics/MethodLength
+      prepare(sql) do |stmt|
+        result = stmt.execute(*bind_vars)
+        stmt.parse
+
+        if block_given?
+          yield stmt.columns
+          result.each(&)
+        else
+          return result.each_with_object([stmt.columns]) do |row, arr|
+                   arr << row
+                 end
+        end
+      end
+    end
+
+    def query(sql, bind_vars = [])
+      result = prepare(sql).execute(bind_vars)
+      if block_given?
+        yield result
+      else
+        result
+      end
+    end
+
+    def query_with_format(sql, bind_vars = [], format = 'CSV')
+      result = prepare(sql).execute_with_format(bind_vars, format)
+      if block_given?
+        yield result
+      else
+        result
+      end
+    end
+
+    def get_first_row(sql, *bind_vars)
+      execute(sql, *bind_vars).first
+    end
+
+    def get_first_value(sql, *bind_vars)
+      query(sql, bind_vars) do |rs|
+        if (row = rs.next)
+          return @results_as_hash ? row[rs.columns[0]] : row[0]
+        end
+      end
+      nil
+    end
+
+    # Returns +true+ if the database has been open in readonly mode
+    # A helper to check before performing any operation
+    def readonly?
+      @readonly
+    end
+
+    # Given a statement, return a result set.
+    # This is not intended for general consumption
+    # :nodoc:
+    def build_result_set(stmt)
+      if results_as_hash
+        HashResultSet.new(self, stmt)
+      else
+        ResultSet.new(self, stmt)
+      end
+    end
+  end
+end

data/lib/chdb/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ChDB
+  # Represents a base exception class for the ChDB module.
+  # This class inherits from StandardError and provides a common
+  # structure for other ChDB-specific exceptions.
+  class Exception < ::StandardError
+    # A convenience for accessing the error code for this exception.
+    attr_reader :code
+
+    # If the error is associated with a SQL query, this is the query
+    attr_reader :sql
+  end
+
+  class SQLException < Exception; end
+
+  class InternalException < Exception; end
+
+  class DirectoryNotFoundException < ChDB::Exception; end
+
+  class InvalidArgumentException < ChDB::Exception; end
+end

data/lib/chdb/local_result.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ChDB
+  # Represents the local result of a ChDB operation.
+  class LocalResult
+    attr_accessor :output_format
+
+    def to_s
+      buf
+    end
+  end
+end

data/lib/chdb/parameter_binding.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ChDB
+  # Documentation for the ParameterBinding module
+  # This module provides methods for binding parameters in a database query context.
+  module ParameterBinding
+    def bind_param(index, value)
+      @bind_vars[index - 1] = value
+    end
+
+    def bind_params(*bind_vars)
+      index = 1
+      bind_vars.flatten.each do |var|
+        if var.is_a?(Hash)
+          # TODO: Hash-style parameter binding not yet implemented
+          # Currently using positional parameters instead of named parameters
+          var.each { |key, val| bind_param key, val }
+        else
+          bind_param index, var
+          index += 1
+        end
+      end
+    end
+  end
+end

data/lib/chdb/result_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ChDB
+  # This module provides a set of methods for handling the results of a ChDB query.
+  # It parses the output content into a CSV table and provides methods to iterate over the rows.
+  module ResultHandler
+    module_function
+
+    def parse_output(output_content)
+      csv_table = CSV.parse(output_content, headers: true)
+      [csv_table.headers, csv_table.map(&:fields)]
+    end
+
+    def step
+      return nil if @row_idx >= @parsed_data.size
+
+      current_row = @parsed_data[@row_idx]
+      @row_idx += 1
+      current_row
+    end
+
+    public
+
+    def done?
+      @row_idx >= @parsed_data.size
+    end
+  end
+end