snowflake_rb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f52d1d74097341acc40cf111a11d5ab1bf403eb59e14dbf0405b78fa4a51d067
+  data.tar.gz: e1fde37704e432fb3ec95825b51c57490e8535f303a9891ece31bc0545187feb
+SHA512:
+  metadata.gz: 81351cbcddcedc5228d22689e7d6bce667a57cf4640e50286da04c91c6feaa00f5c2747d3cc3264ef1238c8f0270045232c9c03d53d70ff16da958bdf3c62ba7
+  data.tar.gz: cfba487d85753ae881613ff6daf91c0d0713d409d93f8f09eb0f45e46258709152a0f360d0efb5f15d39aa0b3548e503f92dba1df34b79b18108167f90d878cd

data/lib/snowflake_rb/configuration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'dry-configurable'
+
+module SnowflakeRB
+  module Configuration
+    extend Dry::Configurable
+
+    setting :account
+    setting :warehouse
+    setting :database
+    setting :schema
+    setting :user
+    setting :password
+    setting :role
+    setting :port, default: 443
+  end
+end

data/lib/snowflake_rb/extension.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SnowflakeRB
+  module Extension
+    def self.env_specific_extension_path
+      "../ext/snowflake-#{os}-#{arch}.so"
+    end
+
+    def self.os
+      case RUBY_PLATFORM
+      when /.*linux.*/
+        'linux'
+      when /.*darwin.*/
+        'darwin'
+      else
+        nil
+      end
+    end
+
+    def self.arch
+      case RUBY_PLATFORM
+      when /.*x86_64.*/
+        'amd64'
+      when /.*arm64.*/
+        'arm64'
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/snowflake_rb.rb

@@ -0,0 +1,164 @@
+require 'ffi'
+require 'snowflake_rb/extension'
+require 'snowflake_rb/configuration'
+
+# Note: this library is not thread safe as it caches the last error
+# The call pattern expectation is to call last_error after any call which may have gotten an error. If last_error is
+# `nil`, there was no error.
+module Snowflake
+  module LibC
+    extend FFI::Library
+    ffi_lib(FFI::Library::LIBC)
+
+    attach_function(:free, [:pointer], :void)
+  end
+
+  module Binding
+    extend FFI::Library
+
+    POINTER_SIZE = FFI.type_size(:pointer)
+
+    ffi_lib(File.expand_path(SnowflakeRB::Extension.env_specific_extension_path, __dir__))
+    attach_function(:last_error, 'LastError', [], :strptr)
+    # ugh, `port` in gosnowflake is just :int; however, ruby - ffi -> go is passing 32bit int if I just decl :int.
+    attach_function(:connect, 'Connect', %i[string string string string string string string int64], :pointer)
+    attach_function(:close, 'Close', [:pointer], :void)
+    attach_function(:exec, 'Exec', %i[pointer string], :int64)
+    attach_function(:fetch, 'Fetch', %i[pointer string], :pointer)
+    attach_function(:next_row, 'NextRow', [:pointer], :pointer)
+    attach_function(:query_columns, 'QueryColumns', [:pointer], :pointer)
+    attach_function(:query_column_count, 'QueryColumnCount', [:pointer], :int32)
+  end
+
+  module Client
+    extend SnowflakeRB::Configuration
+    module_function
+
+    # @return String last error or nil. May be end of file which is not really an error
+    def last_error
+      error, cptr = ::Snowflake::Binding.last_error
+      LibC.free(cptr) if error
+      error
+    end
+
+    # @param account[String] should include everything in the db url ahead of 'snowflakecomputing.com'
+    # @param port[Integer]
+    # @return query_object[Pointer] a pointer to use for subsequent calls not inspectable nor viewable by Ruby
+    def connect(
+      account = nil,
+      warehouse = nil,
+      database = nil,
+      schema = nil,
+      user = nil,
+      password = nil,
+      role = nil,
+      port = nil
+    )
+      ::Snowflake::Binding.connect(
+        account || config.account,
+        warehouse || config.warehouse,
+        database || config.database,
+        schema || config.schema,
+        user || config.user,
+        password || config.password,
+        role || config.role,
+        port || config.port
+      )
+    end
+
+    # @param db_pointer[Pointer] the pointer which `connect` returned.
+    def close(db_pointer)
+      ::Snowflake::Binding.close(db_pointer)
+    end
+
+    # @param db_pointer[Pointer] the pointer which `connect` returned.
+    # @param statement[String] an executable query which should return number of rows affected
+    # @return rowcount[Number] number of rows or nil if there was an error
+    def exec(db_pointer, statement)
+      count = ::Snowflake::Binding.exec(db_pointer, statement) # returns -1 for error
+      count >= 0 ? count : nil
+    end
+
+    # Send a query and then yield each row as an array of strings to the given block
+    # @param db_pointer[Pointer] the pointer which `connect` returned.
+    # @param query[String] a select query to run.
+    # @return error_string
+    # @yield List<String>
+    def select(db_pointer, sql, field_count: nil)
+      return 'db_pointer not initialized' unless db_pointer
+      return to_enum(__method__, db_pointer, sql) unless block_given?
+
+      query_pointer = fetch(db_pointer, sql)
+      return last_error if query_pointer.nil? || query_pointer == FFI::Pointer::NULL
+
+      field_count ||= column_count(query_pointer)
+      loop do
+        row = get_next_row(query_pointer, field_count)
+        return last_error unless row
+
+        yield row
+      end
+      nil
+    end
+
+    # @param db_pointer[Pointer] the pointer which `connect` returned.
+    # @param query[String] a select query to run.
+    # @return query_object[Pointer] a pointer to use for subsequent calls not inspectable nor viewable by Ruby; however,
+    #   if it's `nil`, check `last_error`
+    def fetch(db_pointer, query)
+      ::Snowflake::Binding.fetch(db_pointer, query)
+    end
+
+    # @param query_object[Pointer] the pointer which `fetch` returned. Go will gc this object when the query is done; so,
+    #   don't expect to reference it after the call which returned `nil`
+    # @param field_count[Integer] column count: it will seg fault if you provide a number greater than the actual number.
+    #    Using code should use wrap this in something like
+    #
+    # @return [List<String>] the column values in order
+    def get_next_row(query_object, field_count)
+      raw_row = ::Snowflake::Binding.next_row(query_object)
+      return nil if raw_row.nil? || raw_row == FFI::Pointer::NULL
+
+      raw_row.get_array_of_pointer(0, field_count).map do |cstr|
+        if cstr == FFI::Pointer::NULL || cstr.nil?
+          nil
+        else
+          str = cstr.read_string
+          LibC.free(cstr)
+          str
+        end
+      end
+    ensure
+      LibC.free(raw_row) if raw_row
+    end
+
+    # @param query_object[Pointer] the pointer which `fetch` returned.
+    # @return [List<String>] the column values in order
+    def column_names(query_object, field_count = nil)
+      raw_row = ::Snowflake::Binding.query_columns(query_object)
+      return nil if raw_row.nil? || raw_row == FFI::Pointer::NULL
+
+      raw_row.get_array_of_pointer(0, field_count).map do |cstr|
+        if cstr == FFI::Pointer::NULL || cstr.nil?
+          nil
+        else
+          str = cstr.read_string
+          LibC.free(cstr)
+          str
+        end
+      end
+    ensure
+      LibC.free(raw_row) if raw_row
+    end
+
+    # @param query_object[Pointer] the pointer which `fetch` returned.
+    def column_count(query_object)
+      ::Snowflake::Binding.query_column_count(query_object)
+    end
+
+    # @return [Dry::Configurable::Config] configuration for the gem.
+    def config
+      SnowflakeRB::Configuration.config
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: snowflake_rb
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Darren Cheng
+- Arjun Krishnan
+- Mohammad-Reza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.5
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+description: This gem adds a ruby wrapper around the go native snowflake client
+email:
+- darren@thanx.com
+- arjun@thanx.com
+- mohammad-reza@thanx.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/snowflake-darwin-amd64.so
+- ext/snowflake-darwin-arm64.so
+- ext/snowflake-linux-amd64.so
+- ext/snowflake-linux-arm64.so
+- ext/snowflake.so
+- lib/snowflake_rb.rb
+- lib/snowflake_rb/configuration.rb
+- lib/snowflake_rb/extension.rb
+homepage: https://github.com/thanx/snowflake-rb
+licenses:
+- MIT
+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 wrapper for go native snowflake client
+test_files: []