Patch-overlapping Python context after the fix
src/snowflake/connector/_sql_util.py — function:remove_starting_comments (lines 23-31)
def remove_starting_comments(sql: str) -> str:
"""Remove all comments from the start of a SQL statement."""
commentless_sql = sql
while True:
start_comment = COMMENT_START_SQL_RE.match(commentless_sql)
if start_comment is None:
break
commentless_sql = commentless_sql[start_comment.end() :]
return commentless_sql
src/snowflake/connector/_sql_util.py — function:get_file_transfer_type (lines 34-44)
def get_file_transfer_type(sql: str) -> FileTransferType | None:
"""Decide whether a SQL is a file transfer and return its type.
None is returned if the SQL isn't a file transfer so that this function can be
used in an if-statement.
"""
commentless_sql = remove_starting_comments(sql)
if PUT_SQL_RE.match(commentless_sql):
return FileTransferType.PUT
elif GET_SQL_RE.match(commentless_sql):
return FileTransferType.GET
src/snowflake/connector/_sql_util.py — function:is_put_statement (lines 47-48)
def is_put_statement(sql: str) -> bool:
return get_file_transfer_type(sql) == FileTransferType.PUT
src/snowflake/connector/_sql_util.py — function:is_get_statement (lines 51-52)
def is_get_statement(sql: str) -> bool:
return get_file_transfer_type(sql) == FileTransferType.GET
src/snowflake/connector/_sql_util.py — module:<module>@5 (lines 5-5)
from __future__ import annotations
src/snowflake/connector/_sql_util.py — module:<module>@7 (lines 7-7)
import re
src/snowflake/connector/_sql_util.py — module:<module>@9 (lines 9-9)
from .constants import FileTransferType
src/snowflake/connector/_sql_util.py — module:<module>@11 (lines 11-17)
COMMENT_START_SQL_RE = re.compile(
r"""
^\s*(?:
/\*[\w\W]*?\*/
)""",
re.VERBOSE,
)
src/snowflake/connector/_sql_util.py — module:<module>@19 (lines 19-19)
PUT_SQL_RE = re.compile(r"^\s*put", flags=re.IGNORECASE)
src/snowflake/connector/_sql_util.py — module:<module>@20 (lines 20-20)
GET_SQL_RE = re.compile(r"^\s*get", flags=re.IGNORECASE)
src/snowflake/connector/cursor.py — class:SnowflakeCursor (lines 159-1301)
class SnowflakeCursor:
"""Implementation of Cursor object that is returned from Connection.cursor() method.
Attributes:
description: A list of namedtuples about metadata for all columns.
rowcount: The number of records updated or selected. If not clear, -1 is returned.
rownumber: The current 0-based index of the cursor in the result set or None if the index cannot be
determined.
sfqid: Snowflake query id in UUID form. Include this in the problem report to the customer support.
sqlstate: Snowflake SQL State code.
timestamp_output_format: Snowflake timestamp_output_format for timestamps.
timestamp_ltz_output_format: Snowflake output format for LTZ timestamps.
timestamp_tz_output_format: Snowflake output format for TZ timestamps.
timestamp_ntz_output_format: Snowflake output format for NTZ timestamps.
date_output_format: Snowflake output format for dates.
time_output_format: Snowflake output format for times.
timezone: Snowflake timezone.
binary_output_format: Snowflake output format for binary fields.
arraysize: The default number of rows fetched by fetchmany.
connection: The connection object by which the cursor was created.
errorhandle: The class that handles error handling.
is_file_transfer: Whether, or not the current command is a put, or get.
TODO:
Most of these attributes have no reason to be properties, we could just store them in public variables.
Calling a function is expensive in Python and most of these getters are unnecessary.
"""
INSERT_SQL_RE = re.compile(r"^insert\s+into", flags=re.IGNORECASE)
COMMENT_SQL_RE = re.compile(r"/\*.*\*/")
INSERT_SQL_VALUES_RE = re.compile(
r".*VALUES\s*(\(.*\)).*", re.IGNORECASE | re.MULTILINE | re.DOTALL
)
ALTER_SESSION_RE = re.compile(
r"alter\s+session\s+set\s+(.*)=\'?([^\']+)\'?\s*;",
flags=re.IGNORECASE | re.MULTILINE | re.DOTALL,
)
@staticmethod
def get_file_transfer_type(sql: str) -> FileTransferType | None:
"""Decide whether a SQL is a file transfer and return its type.
None is returned if the SQL isn't a file transfer so that this function can be
used in an if-statement.
"""
return get_file_transfer_type(sql)
def __init__(
self,
connection: SnowflakeConnection,
use_dict_result: bool = False,
) -> None:
"""Inits a SnowflakeCursor with a connection.
Args:
connection: The connection that created this cursor.
use_dict_result: Decides whether to use dict result or not.
"""
self._connection: SnowflakeConnection = connection
self._errorhandler: Callable[
[SnowflakeConnection, SnowflakeCursor, type[Error], dict[str, str]],
None,
] = Error.default_errorhandler
self.messages: list[
tuple[type[Error] | type[Exception], dict[str, str | bool]]
] = []
self._timebomb: Timer | None = None
self._description: list[ResultMetadata] | None = None
self._column_idx_to_name = None
self._sfqid = None
self._sqlstate = None
self._total_rowcount = -1
self._sequence_counter = -1
self._request_id = None
self._is_file_transfer = False
self._timestamp_output_format = None
self._timestamp_ltz_output_format = None
self._timestamp_ntz_output_format = None
self._timestamp_tz_output_format = None
self._date_output_format = None
self._time_output_format = None
self._timezone = None
self._binary_output_format = None
self._result: Iterator[tuple] | Iterator[dict] | None = None
self._result_set: ResultSet | None = None
self._result_state: ResultState = ResultState.DEFAULT
self._use_dict_result = use_dict_result
self.query: str | None = None
self._query_result_format: str | None = None
self._arraysize = 1
self._lock_canceling = Lock()
self._first_chunk_time = None
self._log_max_query_length = connection.log_max_query_length
self._inner_cursor: SnowflakeCursor | None = None
self._prefetch_hook = None
self._rownumber: int | None = None
self.reset()
def __del__(self) -> None:
try:
self.close()
except compat.BASE_EXCEPTION_CLASS as e:
if logger.getEffectiveLevel() <= logging.INFO:
logger.info(e)
@property
def description(self) -> list[ResultMetadata]:
return self._description
@property
def rowcount(self):
return self._total_rowcount if self._total_rowcount >= 0 else None
@property
def rownumber(self):
return self._rownumber if self._rownumber >= 0 else None
@property
def sfqid(self):
return self._sfqid
@property
def sqlstate(self):
return self._sqlstate
@property
def timestamp_output_format(self):
return self._timestamp_output_format
@property
def timestamp_ltz_output_format(self):
return (
self._timestamp_ltz_output_format
if self._timestamp_ltz_output_format
else self._timestamp_output_format
)
@property
def timestamp_tz_output_format(self):
return (
self._timestamp_tz_output_format
if self._timestamp_tz_output_format
else self._timestamp_output_format
)
@property
def timestamp_ntz_output_format(self):
return (
self._timestamp_ntz_output_format
if self._timestamp_ntz_output_format
else self._timestamp_output_format
)
@property
def date_output_format(self):
return self._date_output_format
@property
def time_output_format(self):
return self._time_output_format
@property
def timezone(self):
return self._timezone
@property
def binary_output_format(self):
return self._binary_output_format
@property
def arraysize(self):
return self._arraysize
@arraysize.setter
def arraysize(self, value):
self._arraysize = int(value)
@property
def connection(self):
return self._connection
@property
def errorhandler(self):
return self._errorhandler
@errorhandler.setter
def errorhandler(self, value):
logger.debug("setting errorhandler: %s", value)
if value is None:
raise ProgrammingError("Invalid errorhandler is specified")
self._errorhandler = value
@property
def is_file_transfer(self):
"""Whether the command is PUT or GET."""
return hasattr(self, "_is_file_transfer") and self._is_file_transfer
@property
def lastrowid(self) -> None:
"""Snowflake does not support lastrowid in which case None should be returned as per PEP249."""
return None
def callproc(self, procname: str, args: T = ()) -> T:
"""Call a stored procedure.
Args:
procname: The stored procedure to be called.
args: Parameters to be passed into the stored procedure.
Returns:
The input parameters.
"""
marker_format = "%s" if self._connection.is_pyformat else "?"
command = (
f"CALL {procname}({', '.join([marker_format for _ in range(len(args))])})"
)
self.execute(command, args)
return args
def close(self) -> bool | None:
"""Closes the cursor object.
Returns whether the cursor was closed during this call.
"""
try:
if self.is_closed():
return False
with self._lock_canceling:
self.reset(closing=True)
self._connection = None
del self.messages[:]
return True
except Exception:
pass
def is_closed(self):
return self._connection is None or self._connection.is_closed()
def _execute_helper(
self,
query: str,
timeout: int = 0,
statement_params: dict[str, str] | None = None,
binding_params: tuple | dict[str, dict[str, str]] = None,
binding_stage: str | None = None,
is_internal: bool = False,
describe_only: bool = False,
_no_results: bool = False,
_is_put_get=None,
_no_retry: bool = False,
):
del self.messages[:]
if statement_params is not None and not isinstance(statement_params, dict):
Error.errorhandler_wrapper(
self.connection,
self,
ProgrammingError,
{
"msg": "The data type of statement params is invalid. It must be dict.",
"errno": ER_INVALID_VALUE,
},
)
if not CAN_USE_ARROW_RESULT_FORMAT:
logger.debug("Cannot use arrow result format, fallback to json format")
if statement_params is None:
statement_params = {
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT: "JSON"
}
else:
result_format_val = statement_params.get(
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT
)
if str(result_format_val).upper() == "ARROW":
self.check_can_use_arrow_resultset()
elif result_format_val is None:
statement_params[
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT
] = "JSON"
self._sequence_counter = self._connection._next_sequence_counter()
self._request_id = uuid.uuid4()
logger.debug(f"Request id: {self._request_id}")
logger.debug("running query [%s]", self._format_query_for_log(query))
if _is_put_get is not None:
self._is_file_transfer = _is_put_get
else:
self._is_file_transfer = get_file_transfer_type(query) is not None
logger.debug("is_file_transfer: %s", self._is_file_transfer is not None)
real_timeout = (
timeout if timeout and timeout > 0 else self._connection.network_timeout
)
if real_timeout is not None:
self._timebomb = Timer(real_timeout, self.__cancel_query, [query])
self._timebomb.start()
logger.debug("started timebomb in %ss", real_timeout)
else:
self._timebomb = None
original_sigint = signal.getsignal(signal.SIGINT)
def interrupt_handler(*_):
try:
signal.signal(signal.SIGINT, exit_handler)
except (ValueError, TypeError):
pass
try:
if self._timebomb is not None:
self._timebomb.cancel()
logger.debug("cancelled timebomb in finally")
self._timebomb = None
self.__cancel_query(query)
finally:
if original_sigint:
try:
signal.signal(signal.SIGINT, original_sigint)
except (ValueError, TypeError):
pass
raise KeyboardInterrupt
try:
if not original_sigint == exit_handler:
signal.signal(signal.SIGINT, interrupt_handler)
except ValueError:
logger.debug(
"Failed to set SIGINT handler. " "Not in main thread. Ignored..."
)
ret = {"data": {}}
try:
ret = self._connection.cmd_query(
query,
self._sequence_counter,
self._request_id,
binding_params=binding_params,
binding_stage=binding_stage,
is_file_transfer=bool(self._is_file_transfer),
statement_params=statement_params,
is_internal=is_internal,
describe_only=describe_only,
_no_results=_no_results,
_no_retry=_no_retry,
)
finally:
try:
if original_sigint:
signal.signal(signal.SIGINT, original_sigint)
except (ValueError, TypeError):
logger.debug(
"Failed to reset SIGINT handler. Not in main " "thread. Ignored..."
)
if self._timebomb is not None:
self._timebomb.cancel()
logger.debug("cancelled timebomb in finally")
if "data" in ret and "parameters" in ret["data"]:
parameters = ret["data"]["parameters"]
for kv in parameters:
if "TIMESTAMP_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_output_format = kv["value"]
if "TIMESTAMP_NTZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_ntz_output_format = kv["value"]
if "TIMESTAMP_LTZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_ltz_output_format = kv["value"]
if "TIMESTAMP_TZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_tz_output_format = kv["value"]
if "DATE_OUTPUT_FORMAT" in kv["name"]:
self._date_output_format = kv["value"]
if "TIME_OUTPUT_FORMAT" in kv["name"]:
self._time_output_format = kv["value"]
if "TIMEZONE" in kv["name"]:
self._timezone = kv["value"]
if "BINARY_OUTPUT_FORMAT" in kv["name"]:
self._binary_output_format = kv["value"]
self._connection._update_parameters(
{p["name"]: p["value"] for p in parameters}
)
self.query = query
self._sequence_counter = -1
return ret
def execute(
self,
command: str,
params: Sequence[Any] | dict[Any, Any] | None = None,
_bind_stage: str | None = None,
timeout: int | None = None,
_exec_async: bool = False,
_no_retry: bool = False,
_do_reset: bool = True,
_put_callback: SnowflakeProgressPercentage = None,
_put_azure_callback: SnowflakeProgressPercentage = None,
_put_callback_output_stream: IO[str] = sys.stdout,
_get_callback: SnowflakeProgressPercentage = None,
_get_azure_callback: SnowflakeProgressPercentage = None,
_get_callback_output_stream: IO[str] = sys.stdout,
_show_progress_bar: bool = True,
_statement_params: dict[str, str] | None = None,
_is_internal: bool = False,
_describe_only: bool = False,
_no_results: bool = False,
_is_put_get: bool | None = None,
_raise_put_get_error: bool = True,
_force_put_overwrite: bool = False,
file_stream: IO[bytes] | None = None,
) -> SnowflakeCursor | None:
"""Executes a command/query.
Args:
command: The SQL command to be executed.
params: Parameters to be bound into the SQL statement.
_bind_stage: Path in temporary stage where binding parameters are uploaded as CSV files.
timeout: Number of seconds after which to abort the query.
_exec_async: Whether to execute this query asynchronously.
_no_retry: Whether or not to retry on known errors.
_do_reset: Whether or not the result set needs to be reset before executing query.
_put_callback: Function to which GET command should call back to.
_put_azure_callback: Function to which an Azure GET command should call back to.
_put_callback_output_stream: The output stream a PUT command's callback should report on.
_get_callback: Function to which GET command should call back to.
_get_azure_callback: Function to which an Azure GET command should call back to.
_get_callback_output_stream: The output stream a GET command's callback should report on.
_show_progress_bar: Whether or not to show progress bar.
_statement_params: Extra information that should be sent to Snowflake with query.
_is_internal: This flag indicates whether the query is issued internally by the connector.
_describe_only: If true, the query will not be executed but return the schema/description of this query.
_no_results: This flag tells the back-end to not return the result, just fire the query and return the
response returned by Snowflake's server.
_use_ijson: This flag doesn't do anything as ijson support has ended.
_is_put_get: Force decision of this SQL query being a PUT, or GET command. This is detected otherwise.
_raise_put_get_error: Whether to raise PUT and GET errors.
_force_put_overwrite: If the SQL query is a PUT, then this flag can force overwriting of an already
existing file on stage.
file_stream: File-like object to be uploaded with PUT
Returns:
The cursor itself, or None if some error happened, or the response returned
by Snowflake if the _no_results flag is on.
"""
if _exec_async:
_no_results = True
logger.debug("executing SQL/command")
if self.is_closed():
Error.errorhandler_wrapper(
self.connection,
self,
InterfaceError,
{"msg": "Cursor is closed in execute.", "errno": ER_CURSOR_IS_CLOSED},
)
if _do_reset:
self.reset()
command = command.strip(" \t\n\r") if command else None
if not command:
logger.warning("execute: no query is given to execute")
return
kwargs = {
"timeout": timeout,
"statement_params": _statement_params,
"is_internal": _is_internal,
"describe_only": _describe_only,
"_no_results": _no_results,
"_is_put_get": _is_put_get,
"_no_retry": _no_retry,
}
if self._connection.is_pyformat:
processed_params = self._connection._process_params_pyformat(params, self)
if params is not None and len(params) == 0:
self._log_telemetry_job_data(
TelemetryField.EMPTY_SEQ_INTERPOLATION,
TelemetryData.TRUE
if self.connection._interpolate_empty_sequences
else TelemetryData.FALSE,
)
if logger.getEffectiveLevel() <= logging.DEBUG:
logger.debug(
f"binding: [{self._format_query_for_log(command)}] "
f"with input=[{params}], "
f"processed=[{processed_params}]",
)
if (
self.connection._interpolate_empty_sequences
and processed_params is not None
) or (
not self.connection._interpolate_empty_sequences
and len(processed_params) > 0
):
query = command % processed_params
else:
query = command
else:
query = command
if _bind_stage:
kwargs["binding_stage"] = _bind_stage
else:
if params is not None and not isinstance(params, (list, tuple)):
errorvalue = {
"msg": f"Binding parameters must be a list: {params}",
"errno": ER_FAILED_PROCESSING_PYFORMAT,
}
Error.errorhandler_wrapper(
self.connection, self, ProgrammingError, errorvalue
)
kwargs["binding_params"] = self._connection._process_params_qmarks(
params, self
)
m = DESC_TABLE_RE.match(query)
if m:
query1 = f"describe table {m.group(1)}"
if logger.getEffectiveLevel() <= logging.WARNING:
logger.info(
"query was rewritten: org=%s, new=%s",
" ".join(line.strip() for line in query.split("\n")),
query1,
)
query = query1
if logger.getEffectiveLevel() <= logging.INFO:
logger.info("query: [%s]", self._format_query_for_log(query))
ret = self._execute_helper(query, **kwargs)
self._sfqid = (
ret["data"]["queryId"]
if "data" in ret and "queryId" in ret["data"]
else None
)
self._sqlstate = (
ret["data"]["sqlState"]
if "data" in ret and "sqlState" in ret["data"]
else None
)
self._first_chunk_time = get_time_millis()
if "data" in ret and "sendResultTime" in ret["data"]:
time_consume_first_result = (
self._first_chunk_time - ret["data"]["sendResultTime"]
)
self._log_telemetry_job_data(
TelemetryField.TIME_CONSUME_FIRST_RESULT, time_consume_first_result
)
logger.debug("sfqid: %s", self.sfqid)
logger.info("query execution done")
if ret["success"]:
logger.debug("SUCCESS")
data = ret["data"]
logger.debug("PUT OR GET: %s", self.is_file_transfer)
if self.is_file_transfer:
sf_file_transfer_agent = SnowflakeFileTransferAgent(
self,
query,
ret,
put_callback=_put_callback,
put_azure_callback=_put_azure_callback,
put_callback_output_stream=_put_callback_output_stream,
get_callback=_get_callback,
get_azure_callback=_get_azure_callback,
get_callback_output_stream=_get_callback_output_stream,
show_progress_bar=_show_progress_bar,
raise_put_get_error=_raise_put_get_error,
force_put_overwrite=_force_put_overwrite
or data.get("overwrite", False),
source_from_stream=file_stream,
multipart_threshold=data.get("threshold"),
use_s3_regional_url=self._connection.enable_stage_s3_privatelink_for_us_east_1,
)
sf_file_transfer_agent.execute()
data = sf_file_transfer_agent.result()
self._total_rowcount = len(data["rowset"]) if "rowset" in data else -1
m = self.ALTER_SESSION_RE.match(query)
if m:
param = m.group(1).upper()
value = m.group(2)
self._connection.converter.set_parameter(param, value)
if _exec_async:
self.connection._async_sfqids[self._sfqid] = None
if _no_results:
self._total_rowcount = (
ret["data"]["total"]
if "data" in ret and "total" in ret["data"]
else -1
)
return data
self._init_result_and_meta(data)
else:
self._total_rowcount = (
ret["data"]["total"] if "data" in ret and "total" in ret["data"] else -1
)
logger.debug(ret)
err = ret["message"]
code = ret.get("code", -1)
if "data" in ret:
err += ret["data"].get("errorMessage", "")
errvalue = {
"msg": err,
"errno": int(code),
"sqlstate": self._sqlstate,
"sfqid": self._sfqid,
}
is_integrity_error = (
code == "100072"
)
error_class = IntegrityError if is_integrity_error else ProgrammingError
Error.errorhandler_wrapper(self.connection, self, error_class, errvalue)
return self
def execute_async(self, *args, **kwargs):
"""Convenience function to execute a query without waiting for results (asynchronously).
This function takes the same arguments as execute, please refer to that function
for documentation.
"""
kwargs["_exec_async"] = True
return self.execute(*args, **kwargs)
def describe(self, *args, **kwargs) -> list[ResultMetadata]:
"""Obtain the schema of the result without executing the query.
This function takes the same arguments as execute, please refer to that function
for documentation.
Returns:
The schema of the result.
"""
kwargs["_describe_only"] = kwargs["_is_internal"] = True
self.execute(*args, **kwargs)
return self._description
def _format_query_for_log(self, query):
return self._connection._format_query_for_log(query)
def _is_dml(self, data):
return (
"statementTypeId" in data
and int(data["statementTypeId"]) in STATEMENT_TYPE_ID_DML_SET
)
def _init_result_and_meta(self, data):
is_dml = self._is_dml(data)
self._query_result_format = data.get("queryResultFormat", "json")
logger.debug("Query result format: %s", self._query_result_format)
if self._total_rowcount == -1 and not is_dml and data.get("total") is not None:
self._total_rowcount = data["total"]
self._description: list[ResultMetadata] = [
ResultMetadata.from_column(col) for col in data["rowtype"]
]
result_chunks = create_batches_from_response(
self, self._query_result_format, data, self._description
)
if not (is_dml or self.is_file_transfer):
logger.info(
"Number of results in first chunk: %s", result_chunks[0].rowcount
)
self._result_set = ResultSet(
self,
result_chunks,
self._connection.client_prefetch_threads,
)
self._rownumber = -1
self._result_state = ResultState.VALID
if is_dml and "rowset" in data and len(data["rowset"]) > 0:
updated_rows = 0
for idx, desc in enumerate(self._description):
if desc[0] in (
"number of rows updated",
"number of multi-joined rows updated",
"number of rows deleted",
) or desc[0].startswith("number of rows inserted"):
updated_rows += int(data["rowset"][0][idx])
if self._total_rowcount == -1:
self._total_rowcount = updated_rows
else:
self._total_rowcount += updated_rows
def check_can_use_arrow_resultset(self):
global CAN_USE_ARROW_RESULT_FORMAT
if not CAN_USE_ARROW_RESULT_FORMAT:
if self._connection.application == "SnowSQL":
msg = "Currently SnowSQL doesn't support the result set in Apache Arrow format."
errno = ER_NO_PYARROW_SNOWSQL
else:
msg = "The result set in Apache Arrow format is not supported for the platform."
errno = ER_NO_ARROW_RESULT
Error.errorhandler_wrapper(
self.connection,
self,
ProgrammingError,
{
"msg": msg,
"errno": errno,
},
)
def check_can_use_pandas(self):
if not installed_pandas:
msg = (
"Optional dependency: 'pandas' is not installed, please see the following link for install "
"instructions: https://docs.snowflake.com/en/user-guide/python-connector-pandas.html#installation"
)
errno = ER_NO_PYARROW
Error.errorhandler_wrapper(
self.connection,
self,
ProgrammingError,
{
"msg": msg,
"errno": errno,
},
)
def query_result(self, qid):
url = f"/queries/{qid}/result"
ret = self._connection.rest.request(url=url, method="get")
self._sfqid = (
ret["data"]["queryId"]
if "data" in ret and "queryId" in ret["data"]
else None
)
self._sqlstate = (
ret["data"]["sqlState"]
if "data" in ret and "sqlState" in ret["data"]
else None
)
logger.debug("sfqid=%s", self._sfqid)
if ret.get("success"):
data = ret.get("data")
self._init_result_and_meta(data)
else:
logger.info("failed")
logger.debug(ret)
err = ret["message"]
code = ret.get("code", -1)
if "data" in ret:
err += ret["data"].get("errorMessage", "")
errvalue = {
"msg": err,
"errno": int(code),
"sqlstate": self._sqlstate,
"sfqid": self._sfqid,
}
Error.errorhandler_wrapper(
self.connection, self, ProgrammingError, errvalue
)
return self
def fetch_arrow_batches(self) -> Iterator[Table]:
self.check_can_use_arrow_resultset()
if self._query_result_format != "arrow":
raise NotSupportedError
self._log_telemetry_job_data(
TelemetryField.ARROW_FETCH_BATCHES, TelemetryData.TRUE
)
return self._result_set._fetch_arrow_batches()
def fetch_arrow_all(self) -> Table | None:
self.check_can_use_arrow_resultset()
if self._query_result_format != "arrow":
raise NotSupportedError
self._log_telemetry_job_data(TelemetryField.ARROW_FETCH_ALL, TelemetryData.TRUE)
return self._result_set._fetch_arrow_all()
def fetch_pandas_batches(self, **kwargs) -> Iterator[pandas.DataFrame]:
"""Fetches a single Arrow Table."""
self.check_can_use_pandas()
if self._prefetch_hook is not None:
self._prefetch_hook()
if self._query_result_format != "arrow":
raise NotSupportedError
self._log_telemetry_job_data(
TelemetryField.PANDAS_FETCH_BATCHES, TelemetryData.TRUE
)
return self._result_set._fetch_pandas_batches(**kwargs)
def fetch_pandas_all(self, **kwargs) -> pandas.DataFrame:
"""Fetch Pandas dataframes in batches, where 'batch' refers to Snowflake Chunk."""
self.check_can_use_pandas()
if self._prefetch_hook is not None:
self._prefetch_hook()
if self._query_result_format != "arrow":
raise NotSupportedError
self._log_telemetry_job_data(
TelemetryField.PANDAS_FETCH_ALL, TelemetryData.TRUE
)
return self._result_set._fetch_pandas_all(**kwargs)
def abort_query(self, qid):
url = f"/queries/{qid}/abort-request"
ret = self._connection.rest.request(url=url, method="post")
return ret.get("success")
def executemany(
self,
command: str,
seqparams: Sequence[Any] | dict[str, Any],
**kwargs: dict[str, Any],
) -> SnowflakeCursor:
"""Executes a command/query with the given set of parameters sequentially."""
logger.debug("executing many SQLs/commands")
command = command.strip(" \t\n\r") if command else None
if not seqparams:
return self
if self.INSERT_SQL_RE.match(command):
if self._connection.is_pyformat:
logger.debug("rewriting INSERT query")
command_wo_comments = re.sub(self.COMMENT_SQL_RE, "", command)
m = self.INSERT_SQL_VALUES_RE.match(command_wo_comments)
if not m:
Error.errorhandler_wrapper(
self.connection,
self,
InterfaceError,
{
"msg": "Failed to rewrite multi-row insert",
"errno": ER_FAILED_TO_REWRITE_MULTI_ROW_INSERT,
},
)
fmt = m.group(1)
values = []
for param in seqparams:
logger.debug(f"parameter: {param}")
values.append(
fmt % self._connection._process_params_pyformat(param, self)
)
command = command.replace(fmt, ",".join(values), 1)
self.execute(command, **kwargs)
return self
else:
logger.debug("bulk insert")
row_size = len(seqparams[0])
for row in seqparams:
if len(row) != row_size:
error_value = {
"msg": f"Bulk data size don't match. expected: {row_size}, "
f"got: {len(row)}, command: {command}",
"errno": ER_INVALID_VALUE,
}
Error.errorhandler_wrapper(
self.connection, self, InterfaceError, error_value
)
return self
bind_size = len(seqparams) * row_size
bind_stage = None
if (
bind_size
> self.connection._session_parameters[
"CLIENT_STAGE_ARRAY_BINDING_THRESHOLD"
]
> 0
):
try:
rows = self.connection._write_params_to_byte_rows(seqparams)
bind_uploader = BindUploadAgent(self, rows)
bind_uploader.upload()
bind_stage = bind_uploader.stage_path
except BindUploadError:
logger.debug(
"Failed to upload binds to stage, sending binds to "
"Snowflake instead."
)
binding_param = (
None if bind_stage else list(map(list, zip(*seqparams)))
)
self.execute(
command, params=binding_param, _bind_stage=bind_stage, **kwargs
)
return self
self.reset()
for param in seqparams:
self.execute(command, params=param, _do_reset=False, **kwargs)
return self
def _result_iterator(
self,
) -> Generator[dict, None, None] | Generator[tuple, None, None]:
"""Yields the elements from _result and raises an exception when appropriate."""
try:
for _next in self._result:
if isinstance(_next, Exception):
Error.errorhandler_wrapper_from_ready_exception(
self._connection,
self,
_next,
)
self._rownumber += 1
yield _next
except TypeError as err:
if self._result_state == ResultState.DEFAULT:
raise err
else:
yield None
def fetchone(self) -> dict | tuple | None:
"""Fetches one row."""
if self._prefetch_hook is not None:
self._prefetch_hook()
if self._result is None and self._result_set is not None:
self._result = iter(self._result_set)
self._result_state = ResultState.VALID
try:
return next(self._result_iterator())
except StopIteration:
return None
def fetchmany(self, size=None):
"""Fetches the number of specified rows."""
if size is None:
size = self.arraysize
if size < 0:
errorvalue = {
"msg": (
"The number of rows is not zero or " "positive number: {}"
).format(size),
"errno": ER_NOT_POSITIVE_SIZE,
}
Error.errorhandler_wrapper(
self.connection, self, ProgrammingError, errorvalue
)
ret = []
while size > 0:
row = self.fetchone()
if row is None:
break
ret.append(row)
if size is not None:
size -= 1
return ret
def fetchall(self) -> list[tuple] | list[dict]:
"""Fetches all of the results."""
ret = []
while True:
row = self.fetchone()
if row is None:
break
ret.append(row)
return ret
def nextset(self):
"""Not supported."""
logger.debug("nop")
return None
def setinputsizes(self, _):
"""Not supported."""
logger.debug("nop")
def setoutputsize(self, _, column=None):
"""Not supported."""
del column
logger.debug("nop")
def scroll(self, value, mode="relative"):
Error.errorhandler_wrapper(
self.connection,
self,
NotSupportedError,
{
"msg": "scroll is not supported.",
"errno": ER_UNSUPPORTED_METHOD,
"sqlstate": SQLSTATE_FEATURE_NOT_SUPPORTED,
},
)
def reset(self, closing=False):
"""Resets the result set."""
if not closing:
self._total_rowcount = -1
if self._result_state != ResultState.DEFAULT:
self._result_state = ResultState.RESET
if self._result is not None:
self._result = None
if self._inner_cursor is not None:
self._inner_cursor.reset(closing=closing)
self._result = None
self._inner_cursor = None
self._prefetch_hook = None
if not self.connection._reuse_results:
self._result_set = None
def __iter__(self) -> Iterator[dict] | Iterator[tuple]:
"""Iteration over the result set."""
if self._result is None and self._result_set is not None:
self._result = iter(self._result_set)
self._result_state = ResultState.VALID
return self._result_iterator()
def __cancel_query(self, query):
if self._sequence_counter >= 0 and not self.is_closed():
logger.debug("canceled. %s, request_id: %s", query, self._request_id)
with self._lock_canceling:
self._connection._cancel_query(query, self._request_id)
def _log_telemetry_job_data(
self, telemetry_field: TelemetryField, value: Any
) -> None:
"""Builds an instance of TelemetryData with the given field and logs it."""
ts = get_time_millis()
try:
self._connection._log_telemetry(
TelemetryData.from_telemetry_data_dict(
from_dict={
TelemetryField.KEY_TYPE.value: telemetry_field.value,
TelemetryField.KEY_SFQID.value: self._sfqid,
TelemetryField.KEY_VALUE.value: value,
},
timestamp=ts,
connection=self._connection,
)
)
except AttributeError:
logger.warning(
"Cursor failed to log to telemetry. Connection object may be None.",
exc_info=True,
)
def __enter__(self):
"""Context manager."""
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Context manager with commit or rollback."""
self.close()
def get_results_from_sfqid(self, sfqid: str):
"""Gets the results from previously ran query."""
def wait_until_ready():
"""Makes sure query has finished executing and once it has retrieves results."""
no_data_counter = 0
retry_pattern_pos = 0
while True:
status = self.connection.get_query_status(sfqid)
if not self.connection.is_still_running(status):
break
if status == QueryStatus.NO_DATA:
no_data_counter += 1
if no_data_counter > ASYNC_NO_DATA_MAX_RETRY:
raise DatabaseError(
"Cannot retrieve data on the status of this query. No information returned "
"from server for query '{}'"
)
time.sleep(
0.5 * ASYNC_RETRY_PATTERN[retry_pattern_pos]
)
if retry_pattern_pos < (len(ASYNC_RETRY_PATTERN) - 1):
retry_pattern_pos += 1
if status != QueryStatus.SUCCESS:
raise DatabaseError(
"Status of query '{}' is {}, results are unavailable".format(
sfqid, status.name
)
)
self._inner_cursor.execute(f"select * from table(result_scan('{sfqid}'))")
self._result = self._inner_cursor._result
self._query_result_format = self._inner_cursor._query_result_format
self._total_rowcount = self._inner_cursor._total_rowcount
self._description = self._inner_cursor._description
self._result_set = self._inner_cursor._result_set
self._result_state = ResultState.VALID
self._rownumber = 0
self._prefetch_hook = None
self.connection.get_query_status_throw_if_error(
sfqid
)
klass = self.__class__
self._inner_cursor = klass(self.connection)
self._sfqid = sfqid
self._prefetch_hook = wait_until_ready
def get_result_batches(self) -> list[ResultBatch] | None:
"""Get the previously executed query's ``ResultBatch`` s if available.
If they are unavailable, in case nothing has been executed yet None will
be returned.
For a detailed description of ``ResultBatch`` s please see the docstring of:
``snowflake.connector.result_batches.ResultBatch``
"""
if self._result_set is None:
return None
self._log_telemetry_job_data(
TelemetryField.GET_PARTITIONS_USED, TelemetryData.TRUE
)
return self._result_set.batches
src/snowflake/connector/cursor.py — function:SnowflakeCursor.get_file_transfer_type (lines 197-204)
def get_file_transfer_type(sql: str) -> FileTransferType | None:
"""Decide whether a SQL is a file transfer and return its type.
None is returned if the SQL isn't a file transfer so that this function can be
used in an if-statement.
"""
return get_file_transfer_type(sql)
src/snowflake/connector/cursor.py — function:SnowflakeCursor._execute_helper (lines 406-560)
def _execute_helper(
self,
query: str,
timeout: int = 0,
statement_params: dict[str, str] | None = None,
binding_params: tuple | dict[str, dict[str, str]] = None,
binding_stage: str | None = None,
is_internal: bool = False,
describe_only: bool = False,
_no_results: bool = False,
_is_put_get=None,
_no_retry: bool = False,
):
del self.messages[:]
if statement_params is not None and not isinstance(statement_params, dict):
Error.errorhandler_wrapper(
self.connection,
self,
ProgrammingError,
{
"msg": "The data type of statement params is invalid. It must be dict.",
"errno": ER_INVALID_VALUE,
},
)
if not CAN_USE_ARROW_RESULT_FORMAT:
logger.debug("Cannot use arrow result format, fallback to json format")
if statement_params is None:
statement_params = {
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT: "JSON"
}
else:
result_format_val = statement_params.get(
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT
)
if str(result_format_val).upper() == "ARROW":
self.check_can_use_arrow_resultset()
elif result_format_val is None:
statement_params[
PARAMETER_PYTHON_CONNECTOR_QUERY_RESULT_FORMAT
] = "JSON"
self._sequence_counter = self._connection._next_sequence_counter()
self._request_id = uuid.uuid4()
logger.debug(f"Request id: {self._request_id}")
logger.debug("running query [%s]", self._format_query_for_log(query))
if _is_put_get is not None:
self._is_file_transfer = _is_put_get
else:
self._is_file_transfer = get_file_transfer_type(query) is not None
logger.debug("is_file_transfer: %s", self._is_file_transfer is not None)
real_timeout = (
timeout if timeout and timeout > 0 else self._connection.network_timeout
)
if real_timeout is not None:
self._timebomb = Timer(real_timeout, self.__cancel_query, [query])
self._timebomb.start()
logger.debug("started timebomb in %ss", real_timeout)
else:
self._timebomb = None
original_sigint = signal.getsignal(signal.SIGINT)
def interrupt_handler(*_):
try:
signal.signal(signal.SIGINT, exit_handler)
except (ValueError, TypeError):
pass
try:
if self._timebomb is not None:
self._timebomb.cancel()
logger.debug("cancelled timebomb in finally")
self._timebomb = None
self.__cancel_query(query)
finally:
if original_sigint:
try:
signal.signal(signal.SIGINT, original_sigint)
except (ValueError, TypeError):
pass
raise KeyboardInterrupt
try:
if not original_sigint == exit_handler:
signal.signal(signal.SIGINT, interrupt_handler)
except ValueError:
logger.debug(
"Failed to set SIGINT handler. " "Not in main thread. Ignored..."
)
ret = {"data": {}}
try:
ret = self._connection.cmd_query(
query,
self._sequence_counter,
self._request_id,
binding_params=binding_params,
binding_stage=binding_stage,
is_file_transfer=bool(self._is_file_transfer),
statement_params=statement_params,
is_internal=is_internal,
describe_only=describe_only,
_no_results=_no_results,
_no_retry=_no_retry,
)
finally:
try:
if original_sigint:
signal.signal(signal.SIGINT, original_sigint)
except (ValueError, TypeError):
logger.debug(
"Failed to reset SIGINT handler. Not in main " "thread. Ignored..."
)
if self._timebomb is not None:
self._timebomb.cancel()
logger.debug("cancelled timebomb in finally")
if "data" in ret and "parameters" in ret["data"]:
parameters = ret["data"]["parameters"]
for kv in parameters:
if "TIMESTAMP_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_output_format = kv["value"]
if "TIMESTAMP_NTZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_ntz_output_format = kv["value"]
if "TIMESTAMP_LTZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_ltz_output_format = kv["value"]
if "TIMESTAMP_TZ_OUTPUT_FORMAT" in kv["name"]:
self._timestamp_tz_output_format = kv["value"]
if "DATE_OUTPUT_FORMAT" in kv["name"]:
self._date_output_format = kv["value"]
if "TIME_OUTPUT_FORMAT" in kv["name"]:
self._time_output_format = kv["value"]
if "TIMEZONE" in kv["name"]:
self._timezone = kv["value"]
if "BINARY_OUTPUT_FORMAT" in kv["name"]:
self._binary_output_format = kv["value"]
self._connection._update_parameters(
{p["name"]: p["value"] for p in parameters}
)
self.query = query
self._sequence_counter = -1
return ret
src/snowflake/connector/cursor.py — module:<module>@35 (lines 35-35)
from ._sql_util import get_file_transfer_type
src/snowflake/connector/gcs_storage_client.py — class:SnowflakeGCSRestClient (lines 48-395)
class SnowflakeGCSRestClient(SnowflakeStorageClient):
def __init__(
self,
meta: SnowflakeFileMeta,
credentials: StorageCredential,
stage_info: dict[str, Any],
cnx: SnowflakeConnection,
command: str,
use_s3_regional_url=False,
) -> None:
"""Creates a client object with given stage credentials.
Args:
stage_info: Access credentials and info of a stage.
Returns:
The client to communicate with GCS.
"""
super().__init__(
meta, stage_info, -1, credentials=credentials, chunked_transfer=False
)
self.stage_info = stage_info
self._command = command
self.meta = meta
self._cursor = cnx.cursor()
self.presigned_url: str = meta.presigned_url or stage_info.get("presignedUrl")
self.security_token = credentials.creds.get("GCS_ACCESS_TOKEN")
if self.security_token:
logger.debug(f"len(GCS_ACCESS_TOKEN): {len(self.security_token)}")
else:
logger.debug("No access token received from GS, requesting presigned url")
self._update_presigned_url()
def _has_expired_token(self, response: requests.Response) -> bool:
return self.security_token and response.status_code == 401
def _has_expired_presigned_url(self, response: requests.Response) -> bool:
presigned_url_expired = (
not self.security_token
) and response.status_code == 400
if presigned_url_expired and self.last_err_is_presigned_url:
logger.debug("Presigned url expiration error two times in a row.")
response.raise_for_status()
self.last_err_is_presigned_url = presigned_url_expired
return presigned_url_expired
def _upload_chunk(self, chunk_id: int, chunk: bytes) -> None:
meta = self.meta
content_encoding = ""
if meta.dst_compression_type is not None:
content_encoding = meta.dst_compression_type.name.lower()
if content_encoding and content_encoding == "gzip":
content_encoding = ""
gcs_headers = {
HTTP_HEADER_CONTENT_ENCODING: content_encoding,
GCS_METADATA_SFC_DIGEST: meta.sha256_digest,
}
if self.encryption_metadata:
gcs_headers.update(
{
GCS_METADATA_ENCRYPTIONDATAPROP: json.dumps(
{
"EncryptionMode": "FullBlob",
"WrappedContentKey": {
"KeyId": "symmKey1",
"EncryptedKey": self.encryption_metadata.key,
"Algorithm": "AES_CBC_256",
},
"EncryptionAgent": {
"Protocol": "1.0",
"EncryptionAlgorithm": "AES_CBC_256",
},
"ContentEncryptionIV": self.encryption_metadata.iv,
"KeyWrappingMetadata": {"EncryptionLibrary": "Java 5.3.0"},
}
),
GCS_METADATA_MATDESC_KEY: self.encryption_metadata.matdesc,
}
)
def generate_url_and_rest_args() -> tuple[
str, dict[str, dict[str | Any, str | None] | bytes]
]:
if not self.presigned_url:
upload_url = self.generate_file_url(
self.stage_info["location"], meta.dst_file_name.lstrip("/")
)
access_token = self.security_token
else:
upload_url = self.presigned_url
access_token: str | None = None
if access_token:
gcs_headers.update({"Authorization": f"Bearer {access_token}"})
rest_args = {"headers": gcs_headers, "data": chunk}
return upload_url, rest_args
response = self._send_request_with_retry(
"PUT", generate_url_and_rest_args, chunk_id
)
response.raise_for_status()
meta.gcs_file_header_digest = gcs_headers[GCS_METADATA_SFC_DIGEST]
meta.gcs_file_header_content_length = meta.upload_size
meta.gcs_file_header_encryption_metadata = json.loads(
gcs_headers.get(GCS_METADATA_ENCRYPTIONDATAPROP, "null")
)
def download_chunk(self, chunk_id: int) -> None:
meta = self.meta
def generate_url_and_rest_args() -> tuple[
str, dict[str, dict[str, str] | bool]
]:
gcs_headers = {}
if not self.presigned_url:
download_url = self.generate_file_url(
self.stage_info["location"], meta.src_file_name.lstrip("/")
)
access_token = self.security_token
gcs_headers["Authorization"] = f"Bearer {access_token}"
else:
download_url = self.presigned_url
rest_args = {"headers": gcs_headers, "stream": True}
return download_url, rest_args
response = self._send_request_with_retry(
"GET", generate_url_and_rest_args, chunk_id
)
response.raise_for_status()
self.write_downloaded_chunk(chunk_id, response.content)
encryption_metadata = None
if response.headers.get(GCS_METADATA_ENCRYPTIONDATAPROP, None):
encryptiondata = json.loads(
response.headers[GCS_METADATA_ENCRYPTIONDATAPROP]
)
if encryptiondata:
encryption_metadata = EncryptionMetadata(
key=encryptiondata["WrappedContentKey"]["EncryptedKey"],
iv=encryptiondata["ContentEncryptionIV"],
matdesc=response.headers[GCS_METADATA_MATDESC_KEY]
if GCS_METADATA_MATDESC_KEY in response.headers
else None,
)
meta.gcs_file_header_digest = response.headers.get(GCS_METADATA_SFC_DIGEST)
meta.gcs_file_header_content_length = len(response.content)
meta.gcs_file_header_encryption_metadata = encryption_metadata
def finish_download(self) -> None:
super().finish_download()
self.meta.src_file_size = os.path.getsize(self.intermediate_dst_path)
def _update_presigned_url(self) -> None:
"""Updates the file metas with presigned urls if any.
Currently only the file metas generated for PUT/GET on a GCP account need the presigned urls.
"""
logger.debug("Updating presigned url")
file_path_to_be_replaced = self._get_local_file_path_from_put_command()
if not file_path_to_be_replaced:
return
file_path_to_replace_with = self.meta.dst_file_name
command_with_single_file = self._command
command_with_single_file = command_with_single_file.replace(
file_path_to_be_replaced, file_path_to_replace_with
)
logger.debug("getting presigned url for %s", file_path_to_replace_with)
ret = self._cursor._execute_helper(command_with_single_file)
stage_info = ret.get("data", dict()).get("stageInfo", dict())
self.meta.presigned_url = stage_info.get("presignedUrl")
self.presigned_url = stage_info.get("presignedUrl")
def _get_local_file_path_from_put_command(self) -> str | None:
"""Get the local file path from PUT command (Logic adopted from JDBC, written by Polita).
Args:
command: Command to be parsed and get the local file path out of.
Returns:
The local file path.
"""
command = self._command
if FILE_PROTOCOL not in self._command or not is_put_statement(command):
return None
file_path_begin_index = command.find(FILE_PROTOCOL)
is_file_path_quoted = command[file_path_begin_index - 1] == "'"
file_path_begin_index += len(FILE_PROTOCOL)
file_path = ""
if is_file_path_quoted:
file_path_end_index = command.find("'", file_path_begin_index)
if file_path_end_index > file_path_begin_index:
file_path = command[file_path_begin_index:file_path_end_index]
else:
index_list = []
for delimiter in [" ", "\n", ";"]:
index = command.find(delimiter, file_path_begin_index)
if index != -1:
index_list += [index]
file_path_end_index = min(index_list) if index_list else -1
if file_path_end_index > file_path_begin_index:
file_path = command[file_path_begin_index:file_path_end_index]
elif file_path_end_index == -1:
file_path = command[file_path_begin_index:]
return file_path
def get_file_header(self, filename: str) -> FileHeader | None:
"""Gets the remote file's metadata.
Args:
filename: Not applicable to GCS.
Returns:
The file header, with expected properties populated or None, based on how the request goes with the
storage provider.
Notes:
Sometimes this method is called to verify that the file has indeed been uploaded. In cases of presigned
url, we have no way of verifying that, except with the http status code of 200 which we have already
confirmed and set the meta.result_status = UPLOADED/DOWNLOADED.
"""
meta = self.meta
if (
meta.result_status == ResultStatus.UPLOADED
or meta.result_status == ResultStatus.DOWNLOADED
):
return FileHeader(
digest=meta.gcs_file_header_digest,
content_length=meta.gcs_file_header_content_length,
encryption_metadata=meta.gcs_file_header_encryption_metadata,
)
elif self.presigned_url:
meta.result_status = ResultStatus.NOT_FOUND_FILE
else:
def generate_url_and_authenticated_headers():
url = self.generate_file_url(
self.stage_info["location"], filename.lstrip("/")
)
gcs_headers = {"Authorization": f"Bearer {self.security_token}"}
rest_args = {"headers": gcs_headers}
return url, rest_args
retry_id = "HEAD"
self.retry_count[retry_id] = 0
response = self._send_request_with_retry(
"HEAD", generate_url_and_authenticated_headers, retry_id
)
if response.status_code == 404:
meta.result_status = ResultStatus.NOT_FOUND_FILE
return None
elif response.status_code == 200:
digest = response.headers.get(GCS_METADATA_SFC_DIGEST, None)
content_length = int(response.headers.get("content-length", "0"))
encryption_metadata = EncryptionMetadata("", "", "")
if response.headers.get(GCS_METADATA_ENCRYPTIONDATAPROP, None):
encryption_data = json.loads(
response.headers[GCS_METADATA_ENCRYPTIONDATAPROP]
)
if encryption_data:
encryption_metadata = EncryptionMetadata(
key=encryption_data["WrappedContentKey"]["EncryptedKey"],
iv=encryption_data["ContentEncryptionIV"],
matdesc=response.headers[GCS_METADATA_MATDESC_KEY]
if GCS_METADATA_MATDESC_KEY in response.headers
else None,
)
meta.result_status = ResultStatus.UPLOADED
return FileHeader(
digest=digest,
content_length=content_length,
encryption_metadata=encryption_metadata,
)
response.raise_for_status()
return None
@staticmethod
def extract_bucket_name_and_path(stage_location: str) -> GcsLocation:
container_name = stage_location
path = ""
if "/" in stage_location:
container_name = stage_location[0 : stage_location.index("/")]
path = stage_location[stage_location.index("/") + 1 :]
if path and not path.endswith("/"):
path += "/"
return GcsLocation(bucket_name=container_name, path=path)
@staticmethod
def generate_file_url(stage_location: str, filename: str) -> str:
gcs_location = SnowflakeGCSRestClient.extract_bucket_name_and_path(
stage_location
)
full_file_path = f"{gcs_location.path}{filename}"
return f"https://storage.googleapis.com/{gcs_location.bucket_name}/{quote(full_file_path)}"
src/snowflake/connector/gcs_storage_client.py — function:SnowflakeGCSRestClient._get_local_file_path_from_put_command (lines 263-301)
def _get_local_file_path_from_put_command(self) -> str | None:
"""Get the local file path from PUT command (Logic adopted from JDBC, written by Polita).
Args:
command: Command to be parsed and get the local file path out of.
Returns:
The local file path.
"""
command = self._command
if FILE_PROTOCOL not in self._command or not is_put_statement(command):
return None
file_path_begin_index = command.find(FILE_PROTOCOL)
is_file_path_quoted = command[file_path_begin_index - 1] == "'"
file_path_begin_index += len(FILE_PROTOCOL)
file_path = ""
if is_file_path_quoted:
file_path_end_index = command.find("'", file_path_begin_index)
if file_path_end_index > file_path_begin_index:
file_path = command[file_path_begin_index:file_path_end_index]
else:
index_list = []
for delimiter in [" ", "\n", ";"]:
index = command.find(delimiter, file_path_begin_index)
if index != -1:
index_list += [index]
file_path_end_index = min(index_list) if index_list else -1
if file_path_end_index > file_path_begin_index:
file_path = command[file_path_begin_index:file_path_end_index]
elif file_path_end_index == -1:
file_path = command[file_path_begin_index:]
return file_path
src/snowflake/connector/gcs_storage_client.py — module:<module>@13 (lines 13-13)
from ._sql_util import is_put_statement
test/unit/test_cursor.py — function:test_get_filetransfer_type (lines 27-51)
def test_get_filetransfer_type(sql, _type):
assert SnowflakeCursor.get_file_transfer_type(sql) == _type
