def execute(self, operation, parameters=None, **kwargs):
"""Prepare and execute a database operation (query or command).
Return values are not defined.
"""
# backward compatibility with Python < 3.7
for kw in ['async', 'async_']:
if kw in kwargs:
async_ = kwargs[kw]
break
else:
async_ = False
# Prepare statement
if parameters is None:
sql = operation
else:
sql = operation % _escaper.escape_args(parameters)
self._reset_state()
self._state = self._STATE_RUNNING
_logger.info('%s', sql)
req = ttypes.TExecuteStatementReq(self._connection.sessionHandle,
sql,
runAsync=async_)
_logger.debug(req)
response = self._connection.client.ExecuteStatement(req)
_check_status(response)
self._operationHandle = response.operationHandle
def execute(self, operation, parameters=None, **kwargs):
"""Prepare and execute a database operation (query or command).
Return values are not defined.
"""
# backward compatibility with Python < 3.7
for kw in ['async', 'async_']:
if kw in kwargs:
async_ = kwargs[kw]
break
else:
async_ = False
for kw in ['config', 'config_']:
if kw in kwargs:
config_ = kwargs[kw]
break
else:
config_ = copy.deepcopy(self.confOverlay) if hasattr(
self, 'confOverlay') else {}
if 'hivevar' in kwargs and isinstance(
kwargs['hivevar'], dict) and hasattr(self, 'set_hivevar'):
self.set_hivevar(kwargs['hivevar'])
# Prepare statement
if parameters is None:
sql = operation
else:
sql = operation % _escaper.escape_args(parameters)
self._reset_state()
self._state = self._STATE_RUNNING
self._connection.set_auth_setting()
req = ttypes.TExecuteStatementReq(self._connection.sessionHandle,
sql,
runAsync=async_,
confOverlay=config_)
_logger.debug(req)
response = self._connection.client.ExecuteStatement(req)
_check_status(response)
self._operationHandle = response.operationHandle
def execute(self, operation, parameters=None):
"""Prepare and execute a database operation (query or command).
Return values are not defined.
"""
# Prepare statement
if parameters is None:
sql = operation
else:
sql = operation % _escaper.escape_args(parameters)
self._reset_state()
self._state = self._STATE_RUNNING
_logger.info('%s', sql)
req = ttypes.TExecuteStatementReq(self._connection.sessionHandle, sql.encode('utf-8'))
_logger.debug(req)
response = self._connection.client.ExecuteStatement(req)
_check_status(response)
self._operationHandle = response.operationHandle
class Cursor(common.DBAPICursor):
"""These objects represent a database cursor, which is used to manage the context of a fetch
operation.
Cursors are not isolated, i.e., any changes done to the database by a cursor are immediately
visible by other cursors or connections.
"""
def __init__(self, connection, arraysize=1000):
self._operationHandle = None
super(Cursor, self).__init__()
self.arraysize = arraysize
self._connection = connection
def _reset_state(self):
"""Reset state about the previous query in preparation for running another query"""
super(Cursor, self)._reset_state()
self._description = None
if self._operationHandle is not None:
request = ttypes.TCloseOperationReq(self._operationHandle)
try:
response = self._connection.client.CloseOperation(request)
_check_status(response)
finally:
self._operationHandle = None
@property
def description(self):
"""This read-only attribute is a sequence of 7-item sequences.
Each of these sequences contains information describing one result column:
- name
- type_code
- display_size (None in current implementation)
- internal_size (None in current implementation)
- precision (None in current implementation)
- scale (None in current implementation)
- null_ok (always True in current implementation)
This attribute will be ``None`` for operations that do not return rows or if the cursor has
not had an operation invoked via the :py:meth:`execute` method yet.
The ``type_code`` can be interpreted by comparing it to the Type Objects specified in the
section below.
"""
if self._operationHandle is None or not self._operationHandle.hasResultSet:
return None
if self._description is None:
req = ttypes.TGetResultSetMetadataReq(self._operationHandle)
response = self._connection.client.GetResultSetMetadata(req)
_check_status(response)
columns = response.schema.columns
self._description = []
for col in columns:
primary_type_entry = col.typeDesc.types[0]
if primary_type_entry.primitiveEntry is None:
# All fancy stuff maps to string
type_code = ttypes.TTypeId._VALUES_TO_NAMES[
ttypes.TTypeId.STRING_TYPE]
else:
type_id = primary_type_entry.primitiveEntry.type
type_code = ttypes.TTypeId._VALUES_TO_NAMES[type_id]
self._description.append(
(col.columnName.decode('utf-8'), type_code.decode('utf-8'),
None, None, None, None, True))
return self._description
def close(self):
"""Close the operation handle"""
self._reset_state()
def execute(self, operation, parameters=None, async=False):
"""Prepare and execute a database operation (query or command).
Return values are not defined.
"""
if not isinstance(operation, unicode):
operation = unicode(operation, 'utf-8')
# Prepare statement
if parameters is None:
sql = operation
else:
sql = operation % _escaper.escape_args(parameters)
self._reset_state()
self._state = self._STATE_RUNNING
_logger.info('%s', sql)
req = ttypes.TExecuteStatementReq(self._connection.sessionHandle,
sql.encode('utf-8'),
runAsync=async)
_logger.debug(req)
response = self._connection.client.ExecuteStatement(req)
_check_status(response)
self._operationHandle = response.operationHandle
