def parse_response(data):
cols = data["columns"]
rows = data["rows"]
if len(cols) == 0:
return {"columns": [], "rows": []}
first_row = rows[0]
columns = []
types = {}
for c in cols:
columns.append({
"name": c,
"type": guess_type(first_row[c]),
"friendly_name": c
})
for col in columns:
types[col["name"]] = col["type"]
for row in rows:
for key, value in row.items():
row[key] = convert_type(value, types[key])
return {"columns": columns, "rows": rows}
def parse_response(data):
cols = data['columns']
rows = data['rows']
if len(cols) == 0:
return {'columns': [], 'rows': []}
first_row = rows[0]
columns = []
types = {}
for c in cols:
columns.append({
'name': c,
'type': guess_type(first_row[c]),
'friendly_name': c
})
for col in columns:
types[col['name']] = col['type']
for row in rows:
for key, value in row.iteritems():
row[key] = convert_type(value, types[key])
return {'columns': columns, 'rows': rows}
def test_detects_booleans(self):
self.assertEqual(guess_type('true'), TYPE_BOOLEAN)
self.assertEqual(guess_type('True'), TYPE_BOOLEAN)
self.assertEqual(guess_type('TRUE'), TYPE_BOOLEAN)
self.assertEqual(guess_type('false'), TYPE_BOOLEAN)
self.assertEqual(guess_type('False'), TYPE_BOOLEAN)
self.assertEqual(guess_type('FALSE'), TYPE_BOOLEAN)
self.assertEqual(guess_type(False), TYPE_BOOLEAN)
def test_detects_booleans(self):
self.assertEqual(guess_type("true"), TYPE_BOOLEAN)
self.assertEqual(guess_type("True"), TYPE_BOOLEAN)
self.assertEqual(guess_type("TRUE"), TYPE_BOOLEAN)
self.assertEqual(guess_type("false"), TYPE_BOOLEAN)
self.assertEqual(guess_type("False"), TYPE_BOOLEAN)
self.assertEqual(guess_type("FALSE"), TYPE_BOOLEAN)
self.assertEqual(guess_type(False), TYPE_BOOLEAN)
def run_query(self, query, user):
child_queries = extract_child_queries(query)
connection = None
cursor = None
try:
connection = sqlite3.connect(':memory:')
query = create_tables_from_child_queries(user, connection, query,
child_queries)
logger.debug('ResultsWithParams running query: {}'.format(query))
cursor = connection.cursor()
cursor.execute(query)
if cursor.description is None:
return None, 'Query completed but it returned no data.'
columns = self.fetch_columns([(d[0], None)
for d in cursor.description])
rows = []
column_names = [c['name'] for c in columns]
for i, row in enumerate(cursor):
if i == 0:
for j, col in enumerate(row):
guess = guess_type(col)
if columns[j]['type'] is None:
columns[j]['type'] = guess
elif columns[j]['type'] != guess:
columns[j]['type'] = TYPE_STRING
rows.append(dict(zip(column_names, row)))
return json_dumps({'columns': columns, 'rows': rows}), None
except KeyboardInterrupt:
if connection:
connection.interrupt()
return None, 'Query cancelled by user.'
finally:
if cursor:
cursor.close()
if connection:
connection.close()
def run_query(self, query, user):
connection = sqlite3.connect(':memory:')
query_ids = extract_query_ids(query)
cached_query_ids = extract_cached_query_ids(query)
create_tables_from_query_ids(user, connection, query_ids,
cached_query_ids)
cursor = connection.cursor()
try:
cursor.execute(query)
if cursor.description is not None:
columns = self.fetch_columns([(i[0], None)
for i in cursor.description])
rows = []
column_names = [c['name'] for c in columns]
for i, row in enumerate(cursor):
for j, col in enumerate(row):
guess = guess_type(col)
if columns[j]['type'] is None:
columns[j]['type'] = guess
elif columns[j]['type'] != guess:
columns[j]['type'] = TYPE_STRING
rows.append(dict(zip(column_names, row)))
data = {'columns': columns, 'rows': rows}
error = None
json_data = json_dumps(data)
else:
error = 'Query completed but it returned no data.'
json_data = None
except KeyboardInterrupt:
connection.cancel()
error = "Query cancelled by user."
json_data = None
finally:
connection.close()
return json_data, error
def run_query(self, query, user):
connection = sqlite3.connect(':memory:')
query_ids = extract_query_ids(query)
cached_query_ids = extract_cached_query_ids(query)
create_tables_from_query_ids(user, connection, query_ids, cached_query_ids)
cursor = connection.cursor()
try:
cursor.execute(query)
if cursor.description is not None:
columns = self.fetch_columns(
[(i[0], None) for i in cursor.description])
rows = []
column_names = [c['name'] for c in columns]
for i, row in enumerate(cursor):
for j, col in enumerate(row):
guess = guess_type(col)
if columns[j]['type'] is None:
columns[j]['type'] = guess
elif columns[j]['type'] != guess:
columns[j]['type'] = TYPE_STRING
rows.append(dict(zip(column_names, row)))
data = {'columns': columns, 'rows': rows}
error = None
json_data = json_dumps(data)
else:
error = 'Query completed but it returned no data.'
json_data = None
except KeyboardInterrupt:
connection.cancel()
error = "Query cancelled by user."
json_data = None
finally:
connection.close()
return json_data, error
def run_query(self, query, user):
connection = sqlite3.connect(":memory:")
query_ids = extract_query_ids(query)
cached_query_ids = extract_cached_query_ids(query)
create_tables_from_query_ids(user, connection, query_ids,
cached_query_ids)
cursor = connection.cursor()
try:
cursor.execute(query)
if cursor.description is not None:
columns = self.fetch_columns([(i[0], None)
for i in cursor.description])
rows = []
column_names = [c["name"] for c in columns]
for i, row in enumerate(cursor):
for j, col in enumerate(row):
guess = guess_type(col)
if columns[j]["type"] is None:
columns[j]["type"] = guess
elif columns[j]["type"] != guess:
columns[j]["type"] = TYPE_STRING
rows.append(dict(zip(column_names, row)))
data = {"columns": columns, "rows": rows}
error = None
json_data = json_dumps(data)
else:
error = "查询成功执行，但查询结果没有数据。"
json_data = None
except (KeyboardInterrupt, JobTimeoutException):
connection.cancel()
raise
finally:
connection.close()
return json_data, error
def parse_response(data):
cols = data['columns']
rows = data['rows']
if len(cols) == 0:
return {'columns': [], 'rows': []}
first_row = rows[0]
columns = []
types = {}
for c in cols:
columns.append({'name': c, 'type': guess_type(first_row[c]), 'friendly_name': c})
for col in columns:
types[col['name']] = col['type']
for row in rows:
for key, value in row.iteritems():
row[key] = convert_type(value, types[key])
return {'columns': columns, 'rows': rows}
def test_handles_unicode(self):
self.assertEqual(guess_type(u'Текст'), TYPE_STRING)
def test_detects_date(self):
self.assertEqual(guess_type('2018-10-31'), TYPE_DATETIME)
def test_detects_float(self):
self.assertEqual(guess_type('3.14'), TYPE_FLOAT)
self.assertEqual(guess_type(3.14), TYPE_FLOAT)
def test_detects_integer(self):
self.assertEqual(guess_type('42'), TYPE_INTEGER)
self.assertEqual(guess_type(42), TYPE_INTEGER)
def test_detects_strings(self):
self.assertEqual(guess_type(None), TYPE_STRING)
self.assertEqual(guess_type(''), TYPE_STRING)
self.assertEqual(guess_type('redash'), TYPE_STRING)
