ruby_snowflake_client 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df1c4a15dca0f71a8d675287c635eec979e7f082164ef0a46e38922d935c64c5
-  data.tar.gz: 5aaeb005099a2726e2d18c38e863d24e0a5a13f605df29794a8e94797e6d88c2
+  metadata.gz: 75899b8f6ba98da01620d76f6d7077ba73ae8dd7fb1177815300b969d0dbf7b5
+  data.tar.gz: 2fdbd266149c69bf17d59c83ab09418ca8f46d23707c5c3d98cc8e6800bf84e2
 SHA512:
-  metadata.gz: 5def488e978d41d6815d102f8b9e33cee3746720ab3ed60720d65ab8f285ab3801611481398ca7e4ab17b22ca8b0c4ccf8183e309d4f7468753065f14c75d5e6
-  data.tar.gz: 462d4579b9cac2309f77e0aafcdf1dcb9d41b263ab44831166eebb5821e2989f1d37b4150126c917f6514ec86d6c93e5a1b4c65ec85464894fa37ecdcebd0a4f
+  metadata.gz: 180122aebc707aeda9e7cff2fad9ab6361b21d027b4dc23961bb64319ae192338091fff3b5600cbc15a86522c39bff2b4402723c7c0dfbd80570bdea3e3f96cb
+  data.tar.gz: 65ab2555c42a044224ee1f5e010f43f7ddc9491205d271bd4459459ee5ffb3f65112bd310742c1bcab797c66e8a590e96f732032142ba3866e2e91afb5feb40b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_snowflake_client (1.0.1)
+    ruby_snowflake_client (1.1.0)
 
 GEM
   remote: https://rubygems.org/

data/ext/c-decl.go

@@ -29,9 +29,9 @@ func goobj_log(obj unsafe.Pointer) {
 }
 
 //export goobj_retain
-func goobj_retain(obj unsafe.Pointer) {
+func goobj_retain(obj unsafe.Pointer, x *C.char) {
 	if LOG_LEVEL > 0 {
-		fmt.Printf("retain obj %v - currently keeping %d\n", obj, len(objects))
+		fmt.Printf("retain obj [%v] %v - currently keeping %d\n", C.GoString(x), obj, len(objects))
 	}
 	objects[obj] = true
 	marked[obj] = 0

data/ext/result.go

@@ -11,28 +11,58 @@ VALUE funcall0param(VALUE obj, ID id);
 import "C"
 
 import (
-	"errors"
 	"fmt"
-	"io"
 	"math/big"
-	"strings"
 	"time"
 
 	gopointer "github.com/mattn/go-pointer"
 )
 
+func wrapRbRaise(err error) {
+	fmt.Printf("[ruby-snowflake-client] Error encountered: %s\n", err.Error())
+	fmt.Printf("[ruby-snowflake-client] Will call `rb_raise`\n")
+	rb_raise(C.rb_eArgError, "%s", err.Error())
+}
+
 func getResultStruct(self C.VALUE) *SnowflakeResult {
-	ivar := C.rb_ivar_get(self, RESULT_IDENTIFIER)
-
-	str := GetGoStruct(ivar)
-	ptr := gopointer.Restore(str)
-	sr, ok := ptr.(*SnowflakeResult)
-	if !ok || sr.rows == nil {
-		rb_raise(C.rb_eArgError, "%s", errors.New("Empty result; please run a query via `client.fetch(\"SQL\")`"))
-		return nil
+	return resultMap[self]
+}
+
+//export GetRowsNoEnum
+func GetRowsNoEnum(self C.VALUE) C.VALUE {
+	res := getResultStruct(self)
+	rows := res.rows
+
+	i := 0
+	t1 := time.Now()
+	var arr []C.VALUE
+
+	for rows.Next() {
+		if i%5000 == 0 {
+			if LOG_LEVEL > 0 {
+				fmt.Println("scanning row: ", i)
+			}
+		}
+		x := res.ScanNextRow(false)
+		objects[x] = true
+		gopointer.Save(x)
+		if LOG_LEVEL > 1 {
+			// This is VERY noisy
+			fmt.Printf("alloced %v\n", &x)
+		}
+		arr = append(arr, x)
+		i = i + 1
+	}
+	if LOG_LEVEL > 0 {
+		fmt.Printf("done with rows.next: %s\n", time.Now().Sub(t1))
+	}
+
+	rbArr := C.rb_ary_new2(C.long(len(arr)))
+	for idx, elem := range arr {
+		C.rb_ary_store(rbArr, C.long(idx), elem)
 	}
 
-	return sr
+	return rbArr
 }
 
 //export GetRows
@@ -62,11 +92,6 @@ func GetRows(self C.VALUE) C.VALUE {
 		fmt.Printf("done with rows.next: %s\n", time.Now().Sub(t1))
 	}
 
-	//empty for GC
-	res.rows = nil
-	res.keptHash = C.Qnil
-	res.cols = []C.VALUE{}
-
 	return self
 }
 
@@ -82,10 +107,6 @@ func ObjNextRow(self C.VALUE) C.VALUE {
 	if rows.Next() {
 		r := res.ScanNextRow(false)
 		return r
-	} else if rows.Err() == io.EOF {
-		res.rows = nil        // free up for gc
-		res.keptHash = C.Qnil // free up for gc
-		res.cols = []C.VALUE{}
 	}
 	return C.Qnil
 }
@@ -97,22 +118,28 @@ func (res SnowflakeResult) ScanNextRow(debug bool) C.VALUE {
 		fmt.Printf("column types: %+v; %+v\n", cts[0], cts[0].ScanType())
 	}
 
-	rawResult := make([]any, len(res.cols))
-	rawData := make([]any, len(res.cols))
+	rawResult := make([]any, len(res.columns))
+	rawData := make([]any, len(res.columns))
 	for i := range rawResult {
 		rawData[i] = &rawResult[i]
 	}
 
 	err := rows.Scan(rawData...)
 	if err != nil {
-		rb_raise(C.rb_eArgError, "Cannot scan row: '%s'", err)
+		err = fmt.Errorf("Cannot scan row: '%s'", err)
+		wrapRbRaise(err)
 	}
 
 	// trick from postgres; keep hash: pg_result.c:1088
-	hash := C.rb_hash_dup(res.keptHash)
+	//hash := C.rb_hash_dup(res.keptHash)
+	hash := C.rb_hash_new()
+	if LOG_LEVEL > 1 {
+		// This is very noisy
+		fmt.Println("alloc'ed new hash", &hash)
+	}
+
 	for idx, raw := range rawResult {
 		raw := raw
-		col_name := res.cols[idx]
 
 		var rbVal C.VALUE
 
@@ -139,43 +166,16 @@ func (res SnowflakeResult) ScanNextRow(debug bool) C.VALUE {
 				str := v
 				rbVal = RbString(str)
 			default:
-				rb_raise(C.rb_eArgError, "Cannot parse type '%s'", fmt.Errorf("%T", v))
+				err := fmt.Errorf("Cannot parse type : '%T'", v)
+				wrapRbRaise(err)
 			}
 		}
-		C.rb_hash_aset(hash, col_name, rbVal)
-	}
-	return hash
-}
-
-func SafeMakeHash(lenght int, cols []C.VALUE) C.VALUE {
-	var hash C.VALUE
-	hash = C.rb_hash_new()
-
-	if LOG_LEVEL > 0 {
-		fmt.Println("starting make hash")
-	}
-	for _, col := range cols {
-		C.rb_hash_aset(hash, col, C.Qnil)
-	}
-	if LOG_LEVEL > 0 {
-		fmt.Println("end make hash", hash)
+		colstr := C.rb_str_new2(C.CString(res.columns[idx]))
+		if LOG_LEVEL > 1 {
+			// This is very noisy
+			fmt.Printf("alloc string: %+v; rubyVal: %+v\n", &colstr, &rbVal)
+		}
+		C.rb_hash_aset(hash, colstr, rbVal)
 	}
 	return hash
 }
-
-func (res *SnowflakeResult) Initialize() {
-	columns, _ := res.rows.Columns()
-	rbArr := C.rb_ary_new2(C.long(len(columns)))
-
-	cols := make([]C.VALUE, len(columns))
-	for idx, colName := range columns {
-		str := strings.ToLower(colName)
-		sym := C.rb_str_new2(C.CString(str))
-		sym = C.rb_str_freeze(sym)
-		cols[idx] = sym
-		C.rb_ary_store(rbArr, C.long(idx), sym)
-	}
-
-	res.cols = cols
-	res.keptHash = SafeMakeHash(len(columns), cols)
-}

data/ext/ruby_snowflake.go

@@ -8,8 +8,9 @@ VALUE ObjFetch(VALUE,VALUE);
 VALUE ObjNextRow(VALUE);
 VALUE Inspect(VALUE);
 VALUE GetRows(VALUE);
+VALUE GetRowsNoEnum(VALUE);
 
-VALUE NewGoStruct(VALUE klass, void *p);
+VALUE NewGoStruct(VALUE klass, char* reason, void *p);
 VALUE GoRetEnum(VALUE,int,VALUE);
 void* GetGoStruct(VALUE obj);
 void RbGcGuard(VALUE ptr);
@@ -21,18 +22,18 @@ import "C"
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"fmt"
+	"strings"
 	"time"
 
-	gopointer "github.com/mattn/go-pointer"
 	sf "github.com/snowflakedb/gosnowflake"
 )
 
 type SnowflakeResult struct {
-	rows     *sql.Rows
-	keptHash C.VALUE
-	cols     []C.VALUE
+	rows *sql.Rows
+	//keptHash C.VALUE
+	columns []string
+	//cols     []C.VALUE
 }
 type SnowflakeClient struct {
 	db *sql.DB
@@ -42,12 +43,13 @@ var rbSnowflakeClientClass C.VALUE
 var rbSnowflakeResultClass C.VALUE
 var rbSnowflakeModule C.VALUE
 
-var DB_IDENTIFIER = C.rb_intern(C.CString("db"))
 var RESULT_IDENTIFIER = C.rb_intern(C.CString("rows"))
 var RESULT_DURATION = C.rb_intern(C.CString("@query_duration"))
 var ERROR_IDENT = C.rb_intern(C.CString("@error"))
 
 var objects = make(map[interface{}]bool)
+var resultMap = make(map[C.VALUE]*SnowflakeResult)
+var clientRef = make(map[C.VALUE]*SnowflakeClient)
 
 var LOG_LEVEL = 0
 var empty C.VALUE = C.Qnil
@@ -78,13 +80,7 @@ func Connect(self C.VALUE, account C.VALUE, warehouse C.VALUE, database C.VALUE,
 		C.rb_ivar_set(self, ERROR_IDENT, RbString(errStr))
 	}
 	rs := SnowflakeClient{db}
-	ptr := gopointer.Save(&rs)
-	rbStruct := C.NewGoStruct(
-		rbSnowflakeClientClass,
-		ptr,
-	)
-
-	C.rb_ivar_set(self, DB_IDENTIFIER, rbStruct)
+	clientRef[self] = &rs
 }
 
 func (x SnowflakeClient) Fetch(statement C.VALUE) C.VALUE {
@@ -113,46 +109,28 @@ func (x SnowflakeClient) Fetch(statement C.VALUE) C.VALUE {
 	}
 
 	result := C.rb_class_new_instance(0, &empty, rbSnowflakeResultClass)
-	rs := SnowflakeResult{rows, C.Qnil, []C.VALUE{}}
-	rs.Initialize()
-	ptr := gopointer.Save(&rs)
-	rbStruct := C.NewGoStruct(
-		rbSnowflakeClientClass,
-		ptr,
-	)
-	C.RbGcGuard(rbStruct)
-	C.RbGcGuard(rbSnowflakeResultClass)
-	C.rb_ivar_set(result, RESULT_IDENTIFIER, rbStruct)
+	cols, _ := rows.Columns()
+	for idx, col := range cols {
+		col := col
+		cols[idx] = strings.ToLower(col)
+	}
+	rs := SnowflakeResult{rows, cols}
+	resultMap[result] = &rs
 	C.rb_ivar_set(result, RESULT_DURATION, RbNumFromDouble(C.double(duration)))
 	return result
 }
 
 //export ObjFetch
 func ObjFetch(self C.VALUE, statement C.VALUE) C.VALUE {
-	var q C.VALUE
-	q = C.rb_ivar_get(self, DB_IDENTIFIER)
-
-	req := C.GetGoStruct(q)
-	f := gopointer.Restore(req)
-	x, ok := f.(*SnowflakeClient)
-	if !ok {
-		rb_raise(C.rb_eArgError, "%s", errors.New("cannot convert x to pointer"))
-	}
+	x, _ := clientRef[self]
 
 	return x.Fetch(statement)
 }
 
 //export Inspect
 func Inspect(self C.VALUE) C.VALUE {
-	q := C.rb_ivar_get(self, DB_IDENTIFIER)
-	if q == C.Qnil {
-		return RbString("Object is not instantiated")
-	}
-
-	req := C.GetGoStruct(q)
-	f := gopointer.Restore(req)
-	x := f.(*SnowflakeClient)
-	return RbString(fmt.Sprintf("%+v", x))
+	x := clientRef[self]
+	return RbString(fmt.Sprintf("Snowflake::Client <%+v>", x))
 }
 
 //export Init_ruby_snowflake_client_ext
@@ -161,10 +139,20 @@ func Init_ruby_snowflake_client_ext() {
 	rbSnowflakeClientClass = C.rb_define_class_under(rbSnowflakeModule, C.CString("Client"), C.rb_cObject)
 	rbSnowflakeResultClass = C.rb_define_class_under(rbSnowflakeModule, C.CString("Result"), C.rb_cObject)
 
+	objects[rbSnowflakeResultClass] = true
+	objects[rbSnowflakeClientClass] = true
+	objects[rbSnowflakeModule] = true
+	objects[RESULT_DURATION] = true
+	objects[ERROR_IDENT] = true
+	C.RbGcGuard(RESULT_DURATION)
+	//C.RbGcGuard(RESULT_IDENTIFIER)
+	C.RbGcGuard(ERROR_IDENT)
+
 	C.rb_define_method(rbSnowflakeResultClass, C.CString("next_row"), (*[0]byte)(C.ObjNextRow), 0)
 	// `get_rows` is private as this can lead to SEGFAULT errors if not invoked
 	// with GC.disable due to undetermined issues caused by the Ruby GC.
 	C.rb_define_private_method(rbSnowflakeResultClass, C.CString("_get_rows"), (*[0]byte)(C.GetRows), 0)
+	C.rb_define_method(rbSnowflakeResultClass, C.CString("get_rows_no_enum"), (*[0]byte)(C.GetRowsNoEnum), 0)
 
 	C.rb_define_private_method(rbSnowflakeClientClass, C.CString("_connect"), (*[0]byte)(C.Connect), 7)
 	C.rb_define_method(rbSnowflakeClientClass, C.CString("inspect"), (*[0]byte)(C.Inspect), 0)

data/ext/wrapper.go

@@ -24,7 +24,7 @@ VALUE RbNumFromLong(long v) {
 	return LONG2NUM(v);
 }
 
-void goobj_retain(void *);
+void goobj_retain(void *, char*);
 void goobj_free(void *);
 void goobj_log(void *);
 void goobj_mark(void *);
@@ -42,9 +42,9 @@ static const rb_data_type_t go_type = {
 };
 
 VALUE
-NewGoStruct(VALUE klass, void *p)
+NewGoStruct(VALUE klass, char* reason, void *p)
 {
-    goobj_retain(p);
+    goobj_retain(p, reason);
     return TypedData_Wrap_Struct(klass, &go_type, p);
 }
 
@@ -125,7 +125,8 @@ func RbString(str string) C.VALUE {
 	if len(str) == 0 {
 		return C.rb_utf8_str_new(nil, C.long(0))
 	}
-	cstr := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&str)))[0]))
+	//cstr := (*C.char)(unsafe.Pointer(&(*(*[]byte)(unsafe.Pointer(&str)))[0]))
+	cstr := C.CString(str)
 	return C.rb_utf8_str_new(cstr, C.long(len(str)))
 }
 

data/lib/ruby_snowflake_client/version.rb

@@ -1,3 +1,3 @@
 module RubySnowflakeClient
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/lib/ruby_snowflake_client.rb

@@ -2,6 +2,15 @@
 
 module Snowflake
   require "ruby_snowflake_client_ext" # build bundle of the go files
+  LOG_LEVEL = 0
+
+  class Error < StandardError
+    attr_reader :details
+
+    def initialize(details)
+      @details = details
+    end
+  end
 
   class Client
     attr_reader :error
@@ -9,9 +18,18 @@ module Snowflake
     # wrapping the function in C as the current CGO has a limitation on
     # accepting variadic arguments for functions.
     def connect(account:"", warehouse:"", database:"", schema: "", user: "", password: "", role: "")
-      _connect(account, warehouse, database, schema, user, password, role)
+      @connection_details = {
+        account: account,
+        warehouse: warehouse,
+        database: database,
+        schema: schema,
+        user: user,
+        role: role
+      }
+
+      _connect(account.dup, warehouse.dup, database.dup, schema.dup, user.dup, password.dup, role.dup)
       if error != nil
-        raise(error)
+        raise Error.new(@connection_details), error
       end
       true
     end
@@ -19,7 +37,7 @@ module Snowflake
     def fetch(sql)
       result = _fetch(sql)
       return result if result.valid?
-      raise(result.error)
+      raise Error.new(@connection_details.merge(sql: sql)), result.error
     end
   end
 
@@ -34,13 +52,24 @@ module Snowflake
     def get_all_rows(&blk)
       GC.disable
       if blk
-        _get_rows(&blk)
+        while r = next_row do
+          yield r
+        end
       else
-        _get_rows.to_a
+        get_rows_array
       end
     ensure
       GC.enable
-      GC.start
     end
+
+    private
+      def get_rows_array
+        arr = []
+        while r = next_row do
+          puts "at #{arr.length}" if arr.length % 15000 == 0 && LOG_LEVEL > 0
+          arr << r
+        end
+        arr
+      end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_snowflake_client
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Rinsed
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-08 00:00:00.000000000 Z
+date: 2023-06-09 00:00:00.000000000 Z
 dependencies: []
 description: |
   Using the `Go` library for Snowflake to query and creating native Ruby objects,