ruby_snowflake_client 1.0.0

data/ext/vendor/github.com/snowflakedb/gosnowflake/parameters.json.tmpl

@@ -0,0 +1,11 @@
+{
+    "testconnection": {
+        "SNOWFLAKE_TEST_USER":      "testuser",
+        "SNOWFLAKE_TEST_PASSWORD":  "testpass",
+        "SNOWFLAKE_TEST_ACCOUNT":   "testaccount",
+        "SNOWFLAKE_TEST_WAREHOUSE": "testwarehouse",
+        "SNOWFLAKE_TEST_DATABASE":  "testdatabase",
+        "SNOWFLAKE_TEST_SCHEMA":    "testschema",
+        "SNOWFLAKE_TEST_ROLE":      "testrole"
+    }
+}

data/ext/vendor/github.com/snowflakedb/gosnowflake/priv_key_test_coding_helper.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2017-2022 Snowflake Computing Inc. All rights reserved.
+
+package gosnowflake
+
+import (
+	"crypto/rsa"
+	"crypto/x509"
+)
+
+func parsePKCS8PrivateKey(block []byte) (*rsa.PrivateKey, error) {
+	privKey, err := x509.ParsePKCS8PrivateKey(block)
+	if err != nil {
+		return nil, &SnowflakeError{
+			Number:  ErrCodePrivateKeyParseError,
+			Message: "Error decoding private key using PKCS8.",
+		}
+	}
+	return privKey.(*rsa.PrivateKey), nil
+}
+
+func marshalPKCS8PrivateKey(key *rsa.PrivateKey) ([]byte, error) {
+	keyInBytes, err := x509.MarshalPKCS8PrivateKey(key)
+	if err != nil {
+		return nil, &SnowflakeError{
+			Number:  ErrCodePrivateKeyParseError,
+			Message: "Error encoding private key using PKCS8."}
+	}
+	return keyInBytes, nil
+
+}

data/ext/vendor/github.com/snowflakedb/gosnowflake/query.go

@@ -0,0 +1,128 @@
+// Copyright (c) 2017-2022 Snowflake Computing Inc. All rights reserved.
+
+package gosnowflake
+
+import (
+	"time"
+)
+
+type resultFormat string
+
+const (
+	jsonFormat  resultFormat = "json"
+	arrowFormat resultFormat = "arrow"
+)
+
+type execBindParameter struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value"`
+}
+
+type execRequest struct {
+	SQLText      string                       `json:"sqlText"`
+	AsyncExec    bool                         `json:"asyncExec"`
+	SequenceID   uint64                       `json:"sequenceId"`
+	IsInternal   bool                         `json:"isInternal"`
+	DescribeOnly bool                         `json:"describeOnly,omitempty"`
+	Parameters   map[string]interface{}       `json:"parameters,omitempty"`
+	Bindings     map[string]execBindParameter `json:"bindings,omitempty"`
+	BindStage    string                       `json:"bindStage,omitempty"`
+}
+
+type execResponseRowType struct {
+	Name       string `json:"name"`
+	ByteLength int64  `json:"byteLength"`
+	Length     int64  `json:"length"`
+	Type       string `json:"type"`
+	Precision  int64  `json:"precision"`
+	Scale      int64  `json:"scale"`
+	Nullable   bool   `json:"nullable"`
+}
+
+type execResponseChunk struct {
+	URL              string `json:"url"`
+	RowCount         int    `json:"rowCount"`
+	UncompressedSize int64  `json:"uncompressedSize"`
+	CompressedSize   int64  `json:"compressedSize"`
+}
+
+type execResponseCredentials struct {
+	AwsKeyID       string `json:"AWS_KEY_ID,omitempty"`
+	AwsSecretKey   string `json:"AWS_SECRET_KEY,omitempty"`
+	AwsToken       string `json:"AWS_TOKEN,omitempty"`
+	AwsID          string `json:"AWS_ID,omitempty"`
+	AwsKey         string `json:"AWS_KEY,omitempty"`
+	AzureSasToken  string `json:"AZURE_SAS_TOKEN,omitempty"`
+	GcsAccessToken string `json:"GCS_ACCESS_TOKEN,omitempty"`
+}
+
+type execResponseStageInfo struct {
+	LocationType          string                  `json:"locationType,omitempty"`
+	Location              string                  `json:"location,omitempty"`
+	Path                  string                  `json:"path,omitempty"`
+	Region                string                  `json:"region,omitempty"`
+	StorageAccount        string                  `json:"storageAccount,omitempty"`
+	IsClientSideEncrypted bool                    `json:"isClientSideEncrypted,omitempty"`
+	Creds                 execResponseCredentials `json:"creds,omitempty"`
+	PresignedURL          string                  `json:"presignedUrl,omitempty"`
+	EndPoint              string                  `json:"endPoint,omitempty"`
+}
+
+// make all data field optional
+type execResponseData struct {
+	// succeed query response data
+	Parameters         []nameValueParameter  `json:"parameters,omitempty"`
+	RowType            []execResponseRowType `json:"rowtype,omitempty"`
+	RowSet             [][]*string           `json:"rowset,omitempty"`
+	RowSetBase64       string                `json:"rowsetbase64,omitempty"`
+	Total              int64                 `json:"total,omitempty"`    // java:long
+	Returned           int64                 `json:"returned,omitempty"` // java:long
+	QueryID            string                `json:"queryId,omitempty"`
+	SQLState           string                `json:"sqlState,omitempty"`
+	DatabaseProvider   string                `json:"databaseProvider,omitempty"`
+	FinalDatabaseName  string                `json:"finalDatabaseName,omitempty"`
+	FinalSchemaName    string                `json:"finalSchemaName,omitempty"`
+	FinalWarehouseName string                `json:"finalWarehouseName,omitempty"`
+	FinalRoleName      string                `json:"finalRoleName,omitempty"`
+	NumberOfBinds      int                   `json:"numberOfBinds,omitempty"`   // java:int
+	StatementTypeID    int64                 `json:"statementTypeId,omitempty"` // java:long
+	Version            int64                 `json:"version,omitempty"`         // java:long
+	Chunks             []execResponseChunk   `json:"chunks,omitempty"`
+	Qrmk               string                `json:"qrmk,omitempty"`
+	ChunkHeaders       map[string]string     `json:"chunkHeaders,omitempty"`
+
+	// ping pong response data
+	GetResultURL      string        `json:"getResultUrl,omitempty"`
+	ProgressDesc      string        `json:"progressDesc,omitempty"`
+	QueryAbortTimeout time.Duration `json:"queryAbortsAfterSecs,omitempty"`
+	ResultIDs         string        `json:"resultIds,omitempty"`
+	ResultTypes       string        `json:"resultTypes,omitempty"`
+	QueryResultFormat string        `json:"queryResultFormat,omitempty"`
+
+	// async response placeholders
+	AsyncResult *snowflakeResult `json:"asyncResult,omitempty"`
+	AsyncRows   *snowflakeRows   `json:"asyncRows,omitempty"`
+
+	// file transfer response data
+	UploadInfo              execResponseStageInfo `json:"uploadInfo,omitempty"`
+	LocalLocation           string                `json:"localLocation,omitempty"`
+	SrcLocations            []string              `json:"src_locations,omitempty"`
+	Parallel                int64                 `json:"parallel,omitempty"`
+	Threshold               int64                 `json:"threshold,omitempty"`
+	AutoCompress            bool                  `json:"autoCompress,omitempty"`
+	SourceCompression       string                `json:"sourceCompression,omitempty"`
+	ShowEncryptionParameter bool                  `json:"clientShowEncryptionParameter,omitempty"`
+	EncryptionMaterial      encryptionWrapper     `json:"encryptionMaterial,omitempty"`
+	PresignedURLs           []string              `json:"presignedUrls,omitempty"`
+	StageInfo               execResponseStageInfo `json:"stageInfo,omitempty"`
+	Command                 string                `json:"command,omitempty"`
+	Kind                    string                `json:"kind,omitempty"`
+	Operation               string                `json:"operation,omitempty"`
+}
+
+type execResponse struct {
+	Data    execResponseData `json:"Data"`
+	Message string           `json:"message"`
+	Code    string           `json:"code"`
+	Success bool             `json:"success"`
+}

data/ext/vendor/github.com/snowflakedb/gosnowflake/release.go

@@ -0,0 +1,8 @@
+// Copyright (c) 2018-2022 Snowflake Computing Inc. All rights reserved.
+
+//go:build !sfdebug
+// +build !sfdebug
+
+package gosnowflake
+
+func debugPanicf(fmt string, args ...interface{}) {}

data/ext/vendor/github.com/snowflakedb/gosnowflake/restful.go

@@ -0,0 +1,489 @@
+// Copyright (c) 2017-2022 Snowflake Computing Inc. All rights reserved.
+
+package gosnowflake
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// HTTP headers
+const (
+	headerSnowflakeToken   = "Snowflake Token=\"%v\""
+	headerAuthorizationKey = "Authorization"
+
+	headerContentTypeApplicationJSON     = "application/json"
+	headerAcceptTypeApplicationSnowflake = "application/snowflake"
+)
+
+// Snowflake Server Error code
+const (
+	queryInProgressCode      = "333333"
+	queryInProgressAsyncCode = "333334"
+	sessionExpiredCode       = "390112"
+	queryNotExecuting        = "000605"
+)
+
+// Snowflake Server Endpoints
+const (
+	loginRequestPath         = "/session/v1/login-request"
+	queryRequestPath         = "/queries/v1/query-request"
+	tokenRequestPath         = "/session/token-request"
+	abortRequestPath         = "/queries/v1/abort-request"
+	authenticatorRequestPath = "/session/authenticator-request"
+	sessionRequestPath       = "/session"
+	heartBeatPath            = "/session/heartbeat"
+)
+
+type (
+	funcGetType  func(context.Context, *snowflakeRestful, *url.URL, map[string]string, time.Duration) (*http.Response, error)
+	funcPostType func(context.Context, *snowflakeRestful, *url.URL, map[string]string, []byte, time.Duration, bool) (*http.Response, error)
+)
+
+type snowflakeRestful struct {
+	Host           string
+	Port           int
+	Protocol       string
+	LoginTimeout   time.Duration // Login timeout
+	RequestTimeout time.Duration // request timeout
+
+	Client        *http.Client
+	TokenAccessor TokenAccessor
+	HeartBeat     *heartbeat
+
+	Connection *snowflakeConn
+
+	FuncPostQuery       func(context.Context, *snowflakeRestful, *url.Values, map[string]string, []byte, time.Duration, UUID, *Config) (*execResponse, error)
+	FuncPostQueryHelper func(context.Context, *snowflakeRestful, *url.Values, map[string]string, []byte, time.Duration, UUID, *Config) (*execResponse, error)
+	FuncPost            funcPostType
+	FuncGet             funcGetType
+	FuncRenewSession    func(context.Context, *snowflakeRestful, time.Duration) error
+	FuncPostAuth        func(context.Context, *snowflakeRestful, *url.Values, map[string]string, []byte, time.Duration) (*authResponse, error)
+	FuncCloseSession    func(context.Context, *snowflakeRestful, time.Duration) error
+	FuncCancelQuery     func(context.Context, *snowflakeRestful, UUID, time.Duration) error
+
+	FuncPostAuthSAML func(context.Context, *snowflakeRestful, map[string]string, []byte, time.Duration) (*authResponse, error)
+	FuncPostAuthOKTA func(context.Context, *snowflakeRestful, map[string]string, []byte, string, time.Duration) (*authOKTAResponse, error)
+	FuncGetSSO       func(context.Context, *snowflakeRestful, *url.Values, map[string]string, string, time.Duration) ([]byte, error)
+}
+
+func (sr *snowflakeRestful) getURL() *url.URL {
+	return &url.URL{
+		Scheme: sr.Protocol,
+		Host:   sr.Host + ":" + strconv.Itoa(sr.Port),
+	}
+}
+
+func (sr *snowflakeRestful) getFullURL(path string, params *url.Values) *url.URL {
+	ret := &url.URL{
+		Scheme: sr.Protocol,
+		Host:   sr.Host + ":" + strconv.Itoa(sr.Port),
+		Path:   path,
+	}
+	if params != nil {
+		ret.RawQuery = params.Encode()
+	}
+	return ret
+}
+
+// Renew the snowflake session if the current token is still the stale token specified
+func (sr *snowflakeRestful) renewExpiredSessionToken(ctx context.Context, timeout time.Duration, expiredToken string) error {
+	err := sr.TokenAccessor.Lock()
+	if err != nil {
+		return err
+	}
+	defer sr.TokenAccessor.Unlock()
+	currentToken, _, _ := sr.TokenAccessor.GetTokens()
+	if expiredToken == currentToken || currentToken == "" {
+		// Only renew the session if the current token is still the expired token or current token is empty
+		return sr.FuncRenewSession(ctx, sr, timeout)
+	}
+	return nil
+}
+
+type renewSessionResponse struct {
+	Data    renewSessionResponseMain `json:"data"`
+	Message string                   `json:"message"`
+	Code    string                   `json:"code"`
+	Success bool                     `json:"success"`
+}
+
+type renewSessionResponseMain struct {
+	SessionToken        string        `json:"sessionToken"`
+	ValidityInSecondsST time.Duration `json:"validityInSecondsST"`
+	MasterToken         string        `json:"masterToken"`
+	ValidityInSecondsMT time.Duration `json:"validityInSecondsMT"`
+	SessionID           int64         `json:"sessionId"`
+}
+
+type cancelQueryResponse struct {
+	Data    interface{} `json:"data"`
+	Message string      `json:"message"`
+	Code    string      `json:"code"`
+	Success bool        `json:"success"`
+}
+
+type telemetryResponse struct {
+	Data    interface{}       `json:"data,omitempty"`
+	Message string            `json:"message"`
+	Code    string            `json:"code"`
+	Success bool              `json:"success"`
+	Headers map[string]string `json:"headers,omitempty"`
+}
+
+func postRestful(
+	ctx context.Context,
+	sr *snowflakeRestful,
+	fullURL *url.URL,
+	headers map[string]string,
+	body []byte,
+	timeout time.Duration,
+	raise4XX bool) (
+	*http.Response, error) {
+	return newRetryHTTP(
+		ctx, sr.Client, http.NewRequest, fullURL, headers, timeout).doPost().setBody(body).doRaise4XX(raise4XX).execute()
+}
+
+func getRestful(
+	ctx context.Context,
+	sr *snowflakeRestful,
+	fullURL *url.URL,
+	headers map[string]string,
+	timeout time.Duration) (
+	*http.Response, error) {
+	return newRetryHTTP(
+		ctx, sr.Client, http.NewRequest, fullURL, headers, timeout).execute()
+}
+
+func postRestfulQuery(
+	ctx context.Context,
+	sr *snowflakeRestful,
+	params *url.Values,
+	headers map[string]string,
+	body []byte,
+	timeout time.Duration,
+	requestID UUID,
+	cfg *Config) (
+	data *execResponse, err error) {
+
+	data, err = sr.FuncPostQueryHelper(ctx, sr, params, headers, body, timeout, requestID, cfg)
+
+	// errors other than context timeout and cancel would be returned to upper layers
+	if err != context.Canceled && err != context.DeadlineExceeded {
+		return data, err
+	}
+
+	if err = sr.FuncCancelQuery(context.TODO(), sr, requestID, timeout); err != nil {
+		return nil, err
+	}
+	return nil, ctx.Err()
+}
+
+func postRestfulQueryHelper(
+	ctx context.Context,
+	sr *snowflakeRestful,
+	params *url.Values,
+	headers map[string]string,
+	body []byte,
+	timeout time.Duration,
+	requestID UUID,
+	cfg *Config) (
+	data *execResponse, err error) {
+	logger.Infof("params: %v", params)
+	params.Add(requestIDKey, requestID.String())
+	params.Add("clientStartTime", strconv.FormatInt(time.Now().Unix(), 10))
+	params.Add(requestGUIDKey, NewUUID().String())
+	token, _, _ := sr.TokenAccessor.GetTokens()
+	if token != "" {
+		headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, token)
+	}
+
+	var resp *http.Response
+	fullURL := sr.getFullURL(queryRequestPath, params)
+	resp, err = sr.FuncPost(ctx, sr, fullURL, headers, body, timeout, true)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		logger.WithContext(ctx).Infof("postQuery: resp: %v", resp)
+		var respd execResponse
+		if err = json.NewDecoder(resp.Body).Decode(&respd); err != nil {
+			logger.WithContext(ctx).Errorf("failed to decode JSON. err: %v", err)
+			return nil, err
+		}
+		if respd.Code == sessionExpiredCode {
+			if err = sr.renewExpiredSessionToken(ctx, timeout, token); err != nil {
+				return nil, err
+			}
+			return sr.FuncPostQuery(ctx, sr, params, headers, body, timeout, requestID, cfg)
+		}
+
+		if queryIDChan := getQueryIDChan(ctx); queryIDChan != nil {
+			queryIDChan <- respd.Data.QueryID
+			close(queryIDChan)
+			ctx = WithQueryIDChan(ctx, nil)
+		}
+
+		isSessionRenewed := false
+
+		// if asynchronous query in progress, kick off retrieval but return object
+		if respd.Code == queryInProgressAsyncCode && isAsyncMode(ctx) {
+			return sr.processAsync(ctx, &respd, headers, timeout, cfg)
+		}
+		for isSessionRenewed || respd.Code == queryInProgressCode ||
+			respd.Code == queryInProgressAsyncCode {
+			if !isSessionRenewed {
+				fullURL = sr.getFullURL(respd.Data.GetResultURL, nil)
+			}
+
+			logger.Info("ping pong")
+			token, _, _ = sr.TokenAccessor.GetTokens()
+			headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, token)
+
+			resp, err = sr.FuncGet(ctx, sr, fullURL, headers, timeout)
+			if err != nil {
+				logger.WithContext(ctx).Errorf("failed to get response. err: %v", err)
+				return nil, err
+			}
+			respd = execResponse{} // reset the response
+			err = json.NewDecoder(resp.Body).Decode(&respd)
+			resp.Body.Close()
+			if err != nil {
+				logger.WithContext(ctx).Errorf("failed to decode JSON. err: %v", err)
+				return nil, err
+			}
+			if respd.Code == sessionExpiredCode {
+				if err = sr.renewExpiredSessionToken(ctx, timeout, token); err != nil {
+					return nil, err
+				}
+				isSessionRenewed = true
+			} else {
+				isSessionRenewed = false
+			}
+		}
+		return &respd, nil
+	}
+	b, err := io.ReadAll(resp.Body)
+	if err != nil {
+		logger.WithContext(ctx).Errorf("failed to extract HTTP response body. err: %v", err)
+		return nil, err
+	}
+	logger.WithContext(ctx).Infof("HTTP: %v, URL: %v, Body: %v", resp.StatusCode, fullURL, b)
+	logger.WithContext(ctx).Infof("Header: %v", resp.Header)
+	return nil, &SnowflakeError{
+		Number:      ErrFailedToPostQuery,
+		SQLState:    SQLStateConnectionFailure,
+		Message:     errMsgFailedToPostQuery,
+		MessageArgs: []interface{}{resp.StatusCode, fullURL},
+	}
+}
+
+func closeSession(ctx context.Context, sr *snowflakeRestful, timeout time.Duration) error {
+	logger.WithContext(ctx).Info("close session")
+	params := &url.Values{}
+	params.Add("delete", "true")
+	params.Add(requestIDKey, getOrGenerateRequestIDFromContext(ctx).String())
+	params.Add(requestGUIDKey, NewUUID().String())
+	fullURL := sr.getFullURL(sessionRequestPath, params)
+
+	headers := getHeaders()
+	token, _, _ := sr.TokenAccessor.GetTokens()
+	headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, token)
+
+	resp, err := sr.FuncPost(ctx, sr, fullURL, headers, nil, 5*time.Second, false)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		var respd renewSessionResponse
+		if err = json.NewDecoder(resp.Body).Decode(&respd); err != nil {
+			logger.WithContext(ctx).Errorf("failed to decode JSON. err: %v", err)
+			return err
+		}
+		if !respd.Success && respd.Code != sessionExpiredCode {
+			c, err := strconv.Atoi(respd.Code)
+			if err != nil {
+				return err
+			}
+			return &SnowflakeError{
+				Number:  c,
+				Message: respd.Message,
+			}
+		}
+		return nil
+	}
+	b, err := io.ReadAll(resp.Body)
+	if err != nil {
+		logger.WithContext(ctx).Errorf("failed to extract HTTP response body. err: %v", err)
+		return err
+	}
+	logger.WithContext(ctx).Infof("HTTP: %v, URL: %v, Body: %v", resp.StatusCode, fullURL, b)
+	logger.WithContext(ctx).Infof("Header: %v", resp.Header)
+	return &SnowflakeError{
+		Number:      ErrFailedToCloseSession,
+		SQLState:    SQLStateConnectionFailure,
+		Message:     errMsgFailedToCloseSession,
+		MessageArgs: []interface{}{resp.StatusCode, fullURL},
+	}
+}
+
+func renewRestfulSession(ctx context.Context, sr *snowflakeRestful, timeout time.Duration) error {
+	logger.WithContext(ctx).Info("start renew session")
+	params := &url.Values{}
+	params.Add(requestIDKey, getOrGenerateRequestIDFromContext(ctx).String())
+	params.Add(requestGUIDKey, NewUUID().String())
+	fullURL := sr.getFullURL(tokenRequestPath, params)
+
+	token, masterToken, _ := sr.TokenAccessor.GetTokens()
+	headers := getHeaders()
+	headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, masterToken)
+
+	body := make(map[string]string)
+	body["oldSessionToken"] = token
+	body["requestType"] = "RENEW"
+
+	var reqBody []byte
+	reqBody, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+
+	resp, err := sr.FuncPost(ctx, sr, fullURL, headers, reqBody, timeout, false)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		var respd renewSessionResponse
+		err = json.NewDecoder(resp.Body).Decode(&respd)
+		if err != nil {
+			logger.WithContext(ctx).Errorf("failed to decode JSON. err: %v", err)
+			return err
+		}
+		if !respd.Success {
+			c, err := strconv.Atoi(respd.Code)
+			if err != nil {
+				return err
+			}
+			return &SnowflakeError{
+				Number:  c,
+				Message: respd.Message,
+			}
+		}
+		sr.TokenAccessor.SetTokens(respd.Data.SessionToken, respd.Data.MasterToken, respd.Data.SessionID)
+		return nil
+	}
+	b, err := io.ReadAll(resp.Body)
+	if err != nil {
+		logger.WithContext(ctx).Errorf("failed to extract HTTP response body. err: %v", err)
+		return err
+	}
+	logger.WithContext(ctx).Infof("HTTP: %v, URL: %v, Body: %v", resp.StatusCode, fullURL, b)
+	logger.WithContext(ctx).Infof("Header: %v", resp.Header)
+	return &SnowflakeError{
+		Number:      ErrFailedToRenewSession,
+		SQLState:    SQLStateConnectionFailure,
+		Message:     errMsgFailedToRenew,
+		MessageArgs: []interface{}{resp.StatusCode, fullURL},
+	}
+}
+
+func getCancelRetry(ctx context.Context) int {
+	val := ctx.Value(cancelRetry)
+	if val == nil {
+		return 5
+	}
+	cnt, ok := val.(int)
+	if !ok {
+		return -1
+	}
+	return cnt
+}
+
+func cancelQuery(ctx context.Context, sr *snowflakeRestful, requestID UUID, timeout time.Duration) error {
+	logger.WithContext(ctx).Info("cancel query")
+	params := &url.Values{}
+	params.Add(requestIDKey, getOrGenerateRequestIDFromContext(ctx).String())
+	params.Add(requestGUIDKey, NewUUID().String())
+
+	fullURL := sr.getFullURL(abortRequestPath, params)
+
+	headers := getHeaders()
+	token, _, _ := sr.TokenAccessor.GetTokens()
+	headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, token)
+
+	req := make(map[string]string)
+	req[requestIDKey] = requestID.String()
+
+	reqByte, err := json.Marshal(req)
+	if err != nil {
+		return err
+	}
+
+	resp, err := sr.FuncPost(ctx, sr, fullURL, headers, reqByte, timeout, false)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		var respd cancelQueryResponse
+		if err = json.NewDecoder(resp.Body).Decode(&respd); err != nil {
+			logger.WithContext(ctx).Errorf("failed to decode JSON. err: %v", err)
+			return err
+		}
+		ctxRetry := getCancelRetry(ctx)
+		if !respd.Success && respd.Code == sessionExpiredCode {
+			if err = sr.FuncRenewSession(ctx, sr, timeout); err != nil {
+				return err
+			}
+			return sr.FuncCancelQuery(ctx, sr, requestID, timeout)
+		} else if !respd.Success && respd.Code == queryNotExecuting && ctxRetry != 0 {
+			return sr.FuncCancelQuery(context.WithValue(ctx, cancelRetry, ctxRetry-1), sr, requestID, timeout)
+		} else if respd.Success {
+			return nil
+		} else {
+			c, err := strconv.Atoi(respd.Code)
+			if err != nil {
+				return err
+			}
+			return &SnowflakeError{
+				Number:  c,
+				Message: respd.Message,
+			}
+		}
+	}
+	b, err := io.ReadAll(resp.Body)
+	if err != nil {
+		logger.WithContext(ctx).Errorf("failed to extract HTTP response body. err: %v", err)
+		return err
+	}
+	logger.WithContext(ctx).Infof("HTTP: %v, URL: %v, Body: %v", resp.StatusCode, fullURL, b)
+	logger.WithContext(ctx).Infof("Header: %v", resp.Header)
+	return &SnowflakeError{
+		Number:      ErrFailedToCancelQuery,
+		SQLState:    SQLStateConnectionFailure,
+		Message:     errMsgFailedToCancelQuery,
+		MessageArgs: []interface{}{resp.StatusCode, fullURL},
+	}
+}
+
+func getQueryIDChan(ctx context.Context) chan<- string {
+	v := ctx.Value(queryIDChannel)
+	if v == nil {
+		return nil
+	}
+	c, ok := v.(chan<- string)
+	if !ok {
+		return nil
+	}
+	return c
+}