def fetchone(self):
# PEP 249
if not self.has_result_set:
raise ProgrammingError("Tried to fetch but no results.")
try:
return self.next()
except StopIteration:
return None
def executemany(self, operation, seq_of_parameters):
# PEP 249
log.info('Attempting to execute %s queries', len(seq_of_parameters))
for parameters in seq_of_parameters:
self.execute(operation, parameters)
if self.has_result_set:
raise ProgrammingError("Operations that have result sets are "
"not allowed with executemany.")
def executemany(self, operation, seq_of_parameters):
# PEP 249
for parameters in seq_of_parameters:
self.execute(operation, parameters)
if self.has_result_set:
raise ProgrammingError(
"Operations that have result sets are not allowed with executemany."
)
def fetchone(self):
# PEP 249
if not self.has_result_set:
raise ProgrammingError("Tried to fetch but no results.")
log.debug('Fetching a single row')
try:
return next(self)
except StopIteration:
return None
def _bind_parameters(operation, parameters):
# If parameters is a list, assume either qmark, format, or numeric
# format. If not, assume either named or pyformat parameters
if isinstance(parameters, (list, tuple)):
return _bind_parameters_list(operation, parameters)
elif isinstance(parameters, dict):
return _bind_parameters_dict(operation, parameters)
else:
raise ProgrammingError("Query parameters argument should be a "
"list, tuple, or dict object")
def replace_markers(marker, op, parameters):
param_count = len(parameters)
marker_index = 0
while op.find(marker) > -1:
if marker_index < param_count:
op = op.replace(marker, parameters[marker_index], 1)
marker_index += 1
else:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d "
"supplied." %
(marker_index + 1, param_count))
if marker_index != 0 and marker_index != param_count:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d supplied." %
(marker_index + 1, param_count))
return op
def _replace_numeric_markers(operation, string_parameters, paramstyle):
"""
Replaces qname, format, and numeric markers in the given operation, from
the string_parameters list.
Raises ProgrammingError on wrong number of parameters or bindings
when using qmark. There is no error checking on numeric parameters.
"""
def replace_markers(marker, op, parameters):
param_count = len(parameters)
marker_index = 0
start_offset = 0
while True:
found_offset = op.find(marker, start_offset)
if not found_offset > -1:
break
if marker_index < param_count:
op = op[:found_offset]+op[found_offset:].replace(marker, parameters[marker_index], 1)
start_offset = found_offset + len(parameters[marker_index])
marker_index += 1
else:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d "
"supplied." % (marker_index + 1,
param_count))
if marker_index != 0 and marker_index != param_count:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d supplied." %
(marker_index + 1, param_count))
return op
# replace qmark parameters and format parameters
# If paramstyle is explicitly specified don't try to substitue them all
if paramstyle == 'qmark' or paramstyle is None:
operation = replace_markers('?', operation, string_parameters)
if paramstyle == 'format' or paramstyle is None:
operation = replace_markers(r'%s', operation, string_parameters)
# replace numbered parameters
if paramstyle == 'numeric' or paramstyle is None:
operation = re.sub(r'(:)(\d+)', r'{\2}', operation)
# offset by one
operation = operation.format(*[''] + string_parameters)
if paramstyle in {'named', 'pyformat'}:
raise ProgrammingError(
"paramstyle '%s' is not compatible with parameters passed as List."
"please you a dict for you parameters instead or specify"
" a different paramstyle",
paramstyle
)
return operation
def _bind_parameters(operation, parameters):
# If parameters is a list, assume either qmark, format, or numeric
# format. If not, assume either named or pyformat parameters
# now parameter is always a list
# if parameters is a list of dict, we are doing a bulk insert
for parameter in parameters:
if isinstance(parameter, (list, tuple)):
return _bind_parameters_list(operation, parameters)
elif isinstance(parameter, dict):
return _bind_parameters_dict(operation, parameters)
else:
raise ProgrammingError("Query parameters argument should be a "
"list, tuple, or dict object")
def replace_markers(marker, op, parameters):
param_count = len(parameters)
marker_index = 0
start_offset = 0
while True:
found_offset = op.find(marker, start_offset)
if not found_offset > -1:
break
if marker_index < param_count:
op = op[:found_offset]+op[found_offset:].replace(marker, parameters[marker_index], 1)
start_offset = found_offset + len(parameters[marker_index])
marker_index += 1
else:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d "
"supplied." % (marker_index + 1,
param_count))
if marker_index != 0 and marker_index != param_count:
raise ProgrammingError("Incorrect number of bindings "
"supplied. The current statement uses "
"%d or more, and there are %d supplied." %
(marker_index + 1, param_count))
return op
def fetchmany(self, size=None):
# PEP 249
if not self.has_result_set:
raise ProgrammingError("Tried to fetch but no results.")
if size is None:
size = self.arraysize
local_buffer = []
i = 0
while i < size:
try:
local_buffer.append(self.next())
i += 1
except StopIteration:
break
return local_buffer
def fetchmany(self, size=None):
# PEP 249
self._wait_to_finish()
if not self.has_result_set:
raise ProgrammingError("Tried to fetch but no results.")
if size is None:
size = self.arraysize
log.debug('Fetching up to %s result rows', size)
local_buffer = []
i = 0
while i < size:
try:
local_buffer.append(next(self))
i += 1
except StopIteration:
break
return local_buffer
def next(self):
if not self.has_result_set:
raise ProgrammingError(
"Trying to fetch results on an operation with no results.")
if len(self._buffer) > 0:
return self._buffer.pop(0)
elif self._last_operation_active:
# self._buffer is empty here and op is active: try to pull more rows
rows = rpc.fetch_results(self.service, self._last_operation_handle,
self.description, self.buffersize)
self._buffer.extend(rows)
if len(self._buffer) == 0:
raise StopIteration
return self._buffer.pop(0)
else:
# buffer is already empty
raise StopIteration
def next(self):
if not self.has_result_set:
raise ProgrammingError("Trying to fetch results on an operation with no results.")
if len(self._buffer) > 0:
return self._buffer.pop(0)
elif self._last_operation_active:
# self._buffer is empty here and op is active: try to pull more rows
rows = rpc.fetch_internal(self.service,
self._last_operation_handle, self.buffersize)
self._buffer.extend(rows)
if len(self._buffer) == 0:
self._last_operation_active = False
rpc.close_query(self.service, self._last_operation_handle)
raise StopIteration
return self._buffer.pop(0)
else:
# empty buffer and op is now closed: raise StopIteration
raise StopIteration
def __next__(self):
if not self.has_result_set:
raise ProgrammingError(
"Trying to fetch results on an operation with no results.")
if len(self._buffer) > 0:
log.debug('__next__: popping row out of buffer')
return self._buffer.pop()
elif self._last_operation_active:
log.debug('__next__: buffer empty and op is active => fetching '
'more data')
self._buffer = self._last_operation.fetch(self.description,
self.buffersize)
if len(self._buffer) == 0:
log.debug('__next__: no more data to fetch')
raise StopIteration
log.debug('__next__: popping row out of buffer')
return self._buffer.pop()
else:
log.debug('__next__: buffer empty')
raise StopIteration
def get_table_schema(self, table_name, database_name=None):
if database_name is None:
database_name = '.*'
def op():
self._last_operation_string = "RPC_DESCRIBE_TABLE"
self._last_operation_handle = rpc.get_table_schema(self.service,
self.session_handle, table_name, database_name)
self._execute_sync(op)
results = self.fetchall()
if len(results) == 0:
# TODO: the error raised here should be different
raise OperationalError("no schema results for table %s.%s" % (database_name, table_name))
# check that results are derived from a unique table
tables = set()
for col in results:
tables.add((col[1], col[2]))
if len(tables) > 1:
# TODO: the error raised here should be different
raise ProgrammingError("db: %s, table: %s is not unique" % (database_name, table_name))
return [(r[3], r[5]) for r in results]
def __next__(self):
if not self.has_result_set:
raise ProgrammingError(
"Trying to fetch results on an operation with no results.")
if len(self._buffer) > 0:
log.debug('__next__: popping row out of buffer')
return self._buffer.pop(0)
elif self._last_operation_active:
# self._buffer is empty here and op is active: try to pull more
# rows
log.debug('__next__: buffer empty and op is active => fetching '
'more rows')
rows = fetch_results(self.service, self._last_operation_handle,
self.hs2_protocol_version, self.description,
self.buffersize)
self._buffer.extend(rows)
if len(self._buffer) == 0:
log.debug('__next__: no more rows to fetch')
raise StopIteration
log.debug('__next__: popping row out of buffer')
return self._buffer.pop(0)
else:
# buffer is already empty
raise StopIteration
def is_executing(self):
if self._last_operation is None:
raise ProgrammingError("Operation state is not available")
operation_state = self._last_operation.get_status()
return self._op_state_is_executing(operation_state)
def get_profile(self, profile_format=TRuntimeProfileFormat.STRING):
if self._last_operation is None:
raise ProgrammingError("Operation state is not available")
return self._last_operation.get_profile(profile_format=profile_format)
def get_log(self):
if self._last_operation is None:
raise ProgrammingError("Operation state is not available")
return self._last_operation.get_log()
def is_executing(self):
if self._last_operation_handle is None:
raise ProgrammingError("Operation state is not available")
operation_state = get_operation_status(self.service,
self._last_operation_handle)
return self._op_state_is_executing(operation_state)
