-from collections import OrderedDict
from moz_sql_parser import parse
import re
import tables
self.path = path
self.h5file = tables.open_file(path)
- def execute(self, sql, params=None, truncate=False, page_size=None):
+ def execute(self, sql, params=None, truncate=False, page_size=None, max_returned_rows=None):
if params is None:
params = {}
rows = []
parsed_sql = _parse_sql(sql, params)
if parsed_sql['from'] == 'sqlite_master':
- return self._execute_datasette_query(sql, params)
+ rows = self._execute_datasette_query(sql, params)
+ description = (('value',))
+ return rows, truncated, description
table = self.h5file.get_node(parsed_sql['from'])
table_rows = []
# Use 'where' statement or get all the rows
def _cast_param(field, pname):
# Cast value to the column type
- coltype = table.coltypes[field]
+ if type(table) is tables.table.Table:
+ coltype = table.coltypes[field]
+ else:
+ coltype = table.dtype.name
fcast = None
if coltype == 'string':
fcast = str
def _translate_where(where):
# Translate SQL to PyTables expression
+ nonlocal start, end
expr = ''
operator = list(where)[0]
elif operator == 'exists':
pass
elif where == {'eq': ['rowid', 'p0']}:
- nonlocal start, end
start = int(params['p0'])
end = start + 1
+ elif where == {'gt': ['rowid', 'p0']}:
+ start = int(params['p0']) + 1
else:
left, right = where[operator]
if left in params:
query = parsed_sql['where']
# Limit number of rows
+ limit = None
if 'limit' in parsed_sql:
- max_rows = int(parsed_sql['limit'])
- if end - start > max_rows:
- end = start + max_rows
+ limit = int(parsed_sql['limit'])
# Truncate if needed
- if page_size and truncate:
- if end - start > page_size:
- end = start + page_size
- truncated = True
+ if page_size and max_returned_rows and truncate:
+ if max_returned_rows == page_size:
+ max_returned_rows += 1
# Execute query
if query:
rows.append(Row({'count(*)': int(table.nrows)}))
else:
if type(table) is tables.table.Table:
+ count = 0
for table_row in table_rows:
+ count += 1
+ if limit and count > limit:
+ break
+ if truncate and max_returned_rows and count > max_returned_rows:
+ truncated = True
+ break
row = Row()
for field in fields:
field_name = field['value']
else:
# Any kind of array
rowid = start - 1
+ count = 0
for table_row in table_rows:
+ count += 1
+ if limit and count > limit:
+ break
+ if truncate and max_returned_rows and count > max_returned_rows:
+ truncated = True
+ break
row = Row()
rowid += 1
for field in fields:
description.append((field,))
# Return the rows
- if truncate:
- return rows, truncated, tuple(description)
- else:
- return rows
+ return rows, truncated, tuple(description)
def _execute_datasette_query(self, sql, params):
"Datasette special queries for getting tables info"
else:
raise Exception("SQLite queries cannot be executed with this connector")
-class Row(OrderedDict):
- def __getitem__(self, label):
- if type(label) is int:
- return super(OrderedDict, self).__getitem__(list(self.keys())[label])
+class Row(list):
+ def __init__(self, values=None):
+ self.labels = []
+ self.values = []
+ if values:
+ for idx in values:
+ self.__setitem__(idx, values[idx])
+
+ def __setitem__(self, idx, value):
+ if type(idx) is str:
+ if idx in self.labels:
+ self.values[self.labels.index(idx)] = value
+ else:
+ self.labels.append(idx)
+ self.values.append(value)
+ else:
+ self.values[idx] = value
+
+ def __getitem__(self, idx):
+ if type(idx) is str:
+ return self.values[self.labels.index(idx)]
else:
- return super(OrderedDict, self).__getitem__(label)
+ return self.values[idx]
def __iter__(self):
- return self.values().__iter__()
+ return self.values.__iter__()