arrow-datafusion 0.0.1

data/ext/datafusion_ruby/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "datafusion_ruby"
+version = "0.0.1"
+authors = ["Datafusion Contrib Developers"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = "0.3"
+datafusion = { version = "^8.0.0" }

data/ext/datafusion_ruby/Rakefile

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+class RakeCargoHelper
+  attr_reader :gem_name, :crate_name
+
+  def initialize(gem_name:, crate_name:)
+    @gem_name = gem_name
+    @crate_name = crate_name
+  end
+
+  def self.command?(name)
+    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+    ENV["PATH"].split(File::PATH_SEPARATOR).any? do |path|
+      exts.any? do |ext|
+        exe = File.join(path, "#{name}#{ext}")
+        File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+  end
+
+  def self.rust_toolchain
+    str = `rustc --version --verbose`
+    info = str.lines.map { |l| l.chomp.split(/:\s+/, 2) }.drop(1).to_h
+    info["host"]
+  end
+
+  def self.cargo_target_dir
+    return @cargo_target_dir if defined? @cargo_target_dir
+
+    str = `cargo metadata --format-version 1 --offline --no-deps --quiet`
+    begin
+      require "json"
+      dir = JSON.parse(str)["target_directory"]
+    rescue LoadError # json is usually part of the stdlib, but just in case
+      /"target_directory"\s*:\s*"(?<dir>[^"]*)"/ =~ str
+    end
+    @cargo_target_dir = dir || "target"
+  end
+
+  def self.flags
+    cc_flags = Shellwords.split(RbConfig.expand(RbConfig::MAKEFILE_CONFIG["CC"].dup))
+
+    ["-C", "linker=#{cc_flags.shift}",
+    *cc_flags.flat_map { |a| ["-C", "link-arg=#{a}"] },
+    "-L", "native=#{RbConfig::CONFIG["libdir"]}",
+    *dld_flags,
+    *platform_flags]
+  end
+
+  def self.dld_flags
+    Shellwords.split(RbConfig::CONFIG["DLDFLAGS"]).flat_map do |arg|
+      arg = arg.gsub(/\$\((\w+)\)/) do
+        $1 == "DEFFILE" ? nil : RbConfig::CONFIG[name]
+      end.strip
+      next [] if arg.empty?
+
+      transform_flag(arg)
+    end
+  end
+
+  def self.platform_flags
+    return unless RbConfig::CONFIG["target_os"] =~ /mingw/i
+
+    [*Shellwords.split(RbConfig::CONFIG["LIBRUBYARG"]).flat_map { |arg| transform_flag(arg) },
+    "-C", "link-arg=-Wl,--dynamicbase",
+     "-C", "link-arg=-Wl,--disable-auto-image-base",
+     "-C", "link-arg=-static-libgcc"]
+  end
+
+  def self.transform_flag(arg)
+    k, v = arg.split(/(?<=..)/, 2)
+    case k
+    when "-L"
+      [k, "native=#{v}"]
+    when "-l"
+      [k, v]
+    when "-F"
+      ["-l", "framework=#{v}"]
+    else
+      ["-C", "link_arg=#{k}#{v}"]
+    end
+  end
+
+  def install_dir
+    File.expand_path(File.join("..", "..", "lib", gem_name), __dir__)
+  end
+
+  def rust_name
+    prefix = "lib" unless Gem.win_platform?
+    suffix = if RbConfig::CONFIG["target_os"] =~ /darwin/i
+        ".dylib"
+      elsif Gem.win_platform?
+        ".dll"
+      else
+        ".so"
+      end
+    "#{prefix}#{crate_name}#{suffix}"
+  end
+
+  def ruby_name
+    "#{crate_name}.#{RbConfig::CONFIG["DLEXT"]}"
+  end
+end
+
+task default: [:install, :clean]
+
+desc "set dev mode for subsequent task, run like `rake dev install`"
+task :dev do
+  @dev = true
+end
+
+desc "build gem native extension and copy to lib"
+task install: [:cd, :build] do
+  helper = RakeCargoHelper.new(gem_name: "datafusion", crate_name: "datafusion_ruby")
+  profile_dir = @dev ? "debug" : "release"
+  source = File.join(RakeCargoHelper.cargo_target_dir, profile_dir, helper.rust_name)
+  dest = File.join(helper.install_dir, helper.ruby_name)
+  mkdir_p(helper.install_dir)
+  rm(dest) if File.exist?(dest)
+  cp(source, dest)
+end
+
+desc "build gem native extension"
+task build: [:cargo, :cd] do
+  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--", *RakeCargoHelper.flags
+end
+
+desc "clean up release build artifacts"
+task clean: [:cargo, :cd] do
+  sh "cargo clean --release"
+end
+
+desc "clean up build artifacts"
+task clobber: [:cargo, :cd] do
+  sh "cargo clean"
+end
+
+desc "check for cargo"
+task :cargo do
+  raise <<-MSG unless RakeCargoHelper.command?("cargo")
+
+    This gem requires a Rust compiler and the `cargo' build tool to build the
+    gem's native extension. See https://www.rust-lang.org/tools/install for
+    how to install Rust. `cargo' is usually part of the Rust installation.
+  MSG
+
+  raise <<-MSG if Gem.win_platform? && RakeCargoHelper.rust_toolchain !~ /gnu/
+
+    Found Rust toolchain `#{RakeCargoHelper.rust_toolchain}' but the gem native
+    extension requires the gnu toolchain on Windows.
+  MSG
+end
+
+# ensure task is running in the right dir
+task :cd do
+  cd(__dir__) unless __dir__ == pwd
+end

data/ext/datafusion_ruby/src/context.rs

@@ -0,0 +1,14 @@
+use datafusion::execution::context::SessionContext;
+
+#[magnus::wrap(class = "Datafusion::SessionContext")]
+pub(crate) struct RbSessionContext {
+    ctx: SessionContext,
+}
+
+impl RbSessionContext {
+    pub(crate) fn new() -> Self {
+        Self {
+            ctx: SessionContext::new(),
+        }
+    }
+}

data/ext/datafusion_ruby/src/lib.rs

@@ -0,0 +1,11 @@
+use magnus::{define_module, function, prelude::*, Error};
+
+mod context;
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("Datafusion")?;
+    let class = module.define_class("SessionContext", Default::default())?;
+    class.define_singleton_method("new", function!(context::RbSessionContext::new, 0))?;
+    Ok(())
+}

data/lib/datafusion/version.rb

@@ -0,0 +1,3 @@
+module Datafusion
+  VERSION = "0.0.1"
+end

data/lib/datafusion.rb

@@ -0,0 +1 @@
+require_relative "datafusion/datafusion_ruby"

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: arrow-datafusion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Datafusion Contrib Developers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: DataFusion is an extensible query execution framework, written in Rust,
+  that uses Apache Arrow as its in-memory format.
+email: 
+executables: []
+extensions:
+- ext/datafusion_ruby/Rakefile
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- arrow-datafusion.gemspec
+- ext/datafusion_ruby/Cargo.lock
+- ext/datafusion_ruby/Cargo.toml
+- ext/datafusion_ruby/Rakefile
+- ext/datafusion_ruby/src/context.rs
+- ext/datafusion_ruby/src/lib.rs
+- lib/datafusion.rb
+- lib/datafusion/version.rb
+homepage: https://github.com/datafusion-contrib/datafusion-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Ruby bindings of Apache Arrow Datafusion
+test_files: []