def __next__(self):
if self._iter_row_count == self._num_rows:
raise StopIteration()
parameters = self._multi_row_parameters[self._iter_row_count]
if not isinstance(parameters, (list, tuple, dict)):
raise ProgrammingError(
"Prepared statement parameters supplied as %s, shall be list, tuple or dict."
% type(parameters).__name__)
if len(parameters) != len(self._params_metadata):
raise ProgrammingError(
"Prepared statement parameters expected %d supplied %d." %
(len(self._params_metadata), len(parameters)))
row_params = [
self.ParamTuple(p.id, p.datatype, p.length, parameters[p.id])
for p in self._params_metadata
]
self._iter_row_count += 1
return row_params
def format_operation(operation, parameters=None):
if parameters is not None:
e_values = escape_values(parameters)
try:
operation = operation % e_values
except TypeError as msg:
if str(msg) in FORMAT_OPERATION_ERRORS:
# Python DBAPI expects a ProgrammingError in this case
raise ProgrammingError(str(msg))
else:
# some other error message appeared, so just reraise exception:
raise
return operation
def _format_named_query(operation, parameters=None):
# replace named with question marks
markers = _get_keyword_markers(operation)
if parameters is None:
if len(markers) > 0:
raise ProgrammingError(
0, "%d variables should be bound, but 0 variables given : %s" %
(len(markers), operation))
else:
return (operation, ())
qmark_sql = operation
param_values = []
for pos_marker_start in sorted(markers.keys()):
marker = markers[pos_marker_start]
pos_marker_end = pos_marker_start + len(marker) + 1
if marker in parameters:
param_values.append(parameters[marker])
# Insert padding, in order that the position in the error message
# consists with the position in original query.
#
# Only replace the marker at the position found
replaced_marker = " " * len(marker) + "?"
qmark_sql = qmark_sql[:
pos_marker_start] + replaced_marker + qmark_sql[
pos_marker_end:]
else:
raise ProgrammingError(0, ":%s is not set" % (marker, ))
if qmark_sql.count('?') != len(param_values):
raise ProgrammingError(
0,
"%d variables should be bound, but only %d variables given : %s" %
(qmark_sql.count('?'), len(param_values), operation))
return (qmark_sql, tuple(param_values))
def fetchmany(self, size=None):
"""Fetch many rows from select result set.
:param size: Number of rows to return.
:returns: list of row records (tuples)
"""
self._check_closed()
if not self._executed:
raise ProgrammingError("Require execute() first")
if size is None:
size = self.arraysize
column_names = [column[0] for column in self.description
] if self.description else []
result = []
cnt = 0
while cnt != size:
try:
result.append(ResultRow(column_names, next(self._buffer)))
cnt += 1
except StopIteration:
break
if cnt == size or self._received_last_resultset_part:
# No rows are missing or there are no additional rows
return result
request = RequestMessage.new(
self.connection,
RequestSegment(
message_types.FETCHNEXT,
(ResultSetId(self._resultset_id), FetchSize(size - cnt))))
response = self.connection.send_request(request)
resultset_part = response.segments[0].parts[1]
if resultset_part.attribute & 1:
self._received_last_resultset_part = True
result_parts = resultset_part.unpack_rows(self._column_types,
self.connection)
for result_part in result_parts:
result.append(ResultRow(column_names, result_part))
return result
def _check_closed(self):
if self.connection is None or self.connection.closed:
raise ProgrammingError("Cursor closed")
