def process_response(self, response):
data = []
for query in self.queries:
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
need = self.token + stmt + params
hash = hashlib.sha1(bytes_(need)).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'hash': hash,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
})
self.data = {
'queries':data,
'text':text,
}
def process_response(self, response):
data = []
for index, query in enumerate(self.queries):
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
need = self.token + stmt + params
hash = hashlib.sha1(bytes_(need)).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'hash': hash,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
'query_index': index,
})
self.data = {
'queries': data,
'text': text,
}
def sql_explain(self):
query_dict = self.find_query()
stmt = query_dict['statement']
engine_id = query_dict['engine_id']
params = query_dict['parameters']
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engines = self.request.registry.parent_registry.pdtb_sqla_engines
engine = engines[int(engine_id)]()
if engine.name.startswith('sqlite'):
query = 'EXPLAIN QUERY PLAN %s' % stmt
else:
query = 'EXPLAIN %s' % stmt
result = engine.execute(query, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'str': str,
'duration': float(query_dict['duration']),
}
def sql_explain(self):
stmt, params = self.validate()
engine_id = self.request.params['engine_id']
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
[int(engine_id)]()
params = json.loads(params)
if engine.name.startswith('sqlite'):
query = 'EXPLAIN QUERY PLAN %s' % stmt
else:
query = 'EXPLAIN %s' % stmt
result = engine.execute(query, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'str': str,
'duration': float(self.request.params['duration']),
}
def process_response(self, response):
data = []
for index, query in enumerate(self.queries):
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except ValueError:
pass # JSON parameters serialization can generate ValueError
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
data.append(
{
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
'query_index': index,
}
)
self.data = {
'queries': data,
'text': text_,
'engines': self.engines,
}
def process_response(self, response):
data = []
for index, query in enumerate(self.queries):
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
'query_index': index,
})
self.data = {
'queries': data,
'text': text_,
'engines': self.engines,
}
def sql_select(self):
stmt = self.request.params['sql']
params = self.request.params['params']
engine_id = self.request.params['engine_id']
# Validate hash
hash = hashlib.sha1(
bytes_(self.request.exc_history.token + stmt + params)).hexdigest()
if hash != self.request.params['hash']:
raise HTTPBadRequest('Bad token in request')
# Make sure it is a select statement
if not stmt.lower().strip().startswith('select'):
raise HTTPBadRequest('Not a SELECT SQL statement')
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
[int(engine_id)]()
params = json.loads(params)
result = engine.execute(stmt, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'duration': float(self.request.params['duration']),
}
def sql_explain(self):
query_dict = self.find_query()
stmt = query_dict['statement']
engine_id = query_dict['engine_id']
params = query_dict['parameters']
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engines = self.request.registry.parent_registry.pdtb_sqla_engines
engine = engines[int(engine_id)]()
if engine.name.startswith('sqlite'):
query = 'EXPLAIN QUERY PLAN %s' % stmt
else:
query = 'EXPLAIN %s' % stmt
result = engine.execute(query, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'str': str,
'duration': float(query_dict['duration']),
}
def sql_select(self):
stmt = self.request.params['sql']
params = self.request.params['params']
engine_id = self.request.params['engine_id']
# Validate hash
hash = hashlib.sha1(
bytes_(self.request.exc_history.token + stmt +
params)).hexdigest()
if hash != self.request.params['hash']:
raise HTTPBadRequest('Bad token in request')
# Make sure it is a select statement
if not stmt.lower().strip().startswith('select'):
raise HTTPBadRequest('Not a SELECT SQL statement')
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
[int(engine_id)]()
params = json.loads(params)
result = engine.execute(stmt, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'duration': float(self.request.params['duration']),
}
def sql_explain(self):
stmt, params = self.validate()
engine_id = self.request.params['engine_id']
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
[int(engine_id)]()
params = json.loads(params)
if engine.name.startswith('sqlite'):
query = 'EXPLAIN QUERY PLAN %s' % stmt
else:
query = 'EXPLAIN %s' % stmt
result = engine.execute(query, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'str': str,
'duration': float(self.request.params['duration']),
}
def sql_select(self):
stmt = self.request.params["sql"]
params = self.request.params["params"]
engine_id = self.request.params["engine_id"]
# Validate hash
hash = hashlib.sha1(bytes_(self.request.exc_history.token + stmt + params)).hexdigest()
if hash != self.request.params["hash"]:
raise HTTPBadRequest("Bad token in request")
# Make sure it is a select statement
if not stmt.lower().strip().startswith("select"):
raise HTTPBadRequest("Not a SELECT SQL statement")
if not engine_id:
raise HTTPBadRequest("No valid database engine")
engine = getattr(self.request.registry, "pdtb_sqla_engines")[int(engine_id)]()
params = json.loads(params)
result = engine.execute(stmt, params)
return {
"result": result.fetchall(),
"headers": result.keys(),
"sql": format_sql(stmt),
"duration": float(self.request.params["duration"]),
}
def content(self):
if not self.queries:
return "No queries in executed in request."
data = []
for query in self.queries:
stmt = query["statement"]
is_select = stmt.strip().lower().startswith("select")
params = ""
try:
params = url_quote(json.dumps(query["parameters"]))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
need = self.request.exc_history.token + stmt + params
hash = hashlib.sha1(bytes_(need)).hexdigest()
data.append(
{
"engine_id": query["engine_id"],
"duration": query["duration"],
"sql": format_sql(stmt),
"raw_sql": stmt,
"hash": hash,
"parameters": query["parameters"],
"params": params,
"is_select": is_select,
"context": query["context"],
}
)
vars = {
"static_path": self.request.static_url(STATIC_PATH),
"root_path": self.request.route_url(ROOT_ROUTE_NAME),
"queries": data,
"text": text,
}
delattr(self.request, "pdtb_sqla_queries")
return self.render("pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako", vars, self.request)
def content(self):
if not self.queries:
return 'No queries in executed in request.'
data = []
for query in self.queries:
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
need = self.request.exc_history.token + stmt + params
hash = hashlib.sha1(bytes_(need)).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'hash': hash,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
})
vars = {
'static_path': self.request.static_url(STATIC_PATH),
'root_path': self.request.route_url(ROOT_ROUTE_NAME),
'queries': data,
'text': text,
}
delattr(self.request, 'pdtb_sqla_queries')
return self.render(
'pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako', vars,
self.request)
def content(self):
if not self.queries:
return 'No queries in executed in request.'
data = []
for query in self.queries:
stmt = query['statement']
is_select = stmt.strip().lower().startswith('select')
params = ''
try:
params = url_quote(json.dumps(query['parameters']))
except TypeError:
pass # object not JSON serializable
except UnicodeDecodeError:
pass # parameters contain non-utf8 (probably binary) data
need = self.request.exc_history.token + stmt + params
hash = hashlib.sha1(bytes_(need)).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(stmt),
'raw_sql': stmt,
'hash': hash,
'parameters': query['parameters'],
'params': params,
'is_select': is_select,
'context': query['context'],
})
vars = {
'static_path': self.request.static_url(STATIC_PATH),
'root_path': self.request.route_url(ROOT_ROUTE_NAME),
'queries':data,
'text':text,
}
delattr(self.request, 'pdtb_sqla_queries')
return self.render(
'pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako',
vars, self.request)
def content(self):
if not self.queries:
return 'No queries in executed in request.'
data = []
for query in self.queries:
data.append({
'duration': query['duration'],
'sql': format_sql(query['statement']),
'raw_sql': query['statement'],
'params': query['parameters'],
'context': query['context']
})
vars = {'queries': data}
registry = get_current_registry()
del registry['sqla_queries']
return self.render(
'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2',
vars, self.request)
def sql_select(self):
stmt, params = self.validate()
engine_id = self.request.params["engine_id"]
# Make sure it is a select statement
if not stmt.lower().strip().startswith("select"):
raise HTTPBadRequest("Not a SELECT SQL statement")
if not engine_id:
raise HTTPBadRequest("No valid database engine")
engine = getattr(self.request.registry, "pdtb_sqla_engines")[int(engine_id)]()
params = [json.loads(params)]
result = engine.execute(stmt, params)
return {
"result": result.fetchall(),
"headers": result.keys(),
"sql": format_sql(stmt),
"duration": float(self.request.params["duration"]),
}
def sql_select(self):
stmt, params = self.validate()
engine_id = self.request.params['engine_id']
# Make sure it is a select statement
if not stmt.lower().strip().startswith('select'):
raise HTTPBadRequest('Not a SELECT SQL statement')
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engines = self.request.registry.parent_registry.pdtb_sqla_engines
engine = engines[int(engine_id)]()
params = [json.loads(params)]
result = engine.execute(stmt, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'duration': float(self.request.params['duration']),
}
def sql_select(self):
stmt, params = self.validate()
engine_id = self.request.params['engine_id']
# Make sure it is a select statement
if not stmt.lower().strip().startswith('select'):
raise HTTPBadRequest('Not a SELECT SQL statement')
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
[int(engine_id)]()
params = [json.loads(params)]
result = engine.execute(stmt, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'duration': float(self.request.params['duration']),
}
def content(self):
if not self.queries:
return 'No queries in executed in request.'
data = []
for query in self.queries:
is_select = query['statement'].strip().lower().startswith('select')
params = ''
try:
params = json.dumps(query['parameters'])
except TypeError:
pass # object not JSON serializable
hash = hashlib.sha1(
self.request.exc_history.token +
query['statement'] + params).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(query['statement']),
'raw_sql': query['statement'],
'hash': hash,
'params': params,
'is_select': is_select,
'context': query['context'],
})
vars = {
'static_path': self.request.static_url(STATIC_PATH),
'root_path': self.request.route_url(ROOT_ROUTE_NAME),
'queries':data,
}
delattr(self.request, 'pdtb_sqla_queries')
return self.render(
'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2',
vars, self.request)
def sql_select(self):
query_dict = self.find_query()
stmt = query_dict['statement']
engine_id = query_dict['engine_id']
params = query_dict['parameters']
# Make sure it is a select statement
if not stmt.lower().strip().startswith('select'):
raise HTTPBadRequest('Not a SELECT SQL statement')
if not engine_id:
raise HTTPBadRequest('No valid database engine')
engines = self.request.registry.parent_registry.pdtb_sqla_engines
engine = engines[int(engine_id)]()
result = engine.execute(stmt, params)
return {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(stmt),
'duration': float(query_dict['duration']),
}
def content(self):
if not self.queries:
return 'No queries in executed in request.'
data = []
for query in self.queries:
is_select = query['statement'].strip().lower().startswith('select')
params = ''
try:
params = json.dumps(query['parameters'])
except TypeError:
pass # object not JSON serializable
hash = hashlib.sha1(
bytes_(self.request.exc_history.token + query['statement'] +
params)).hexdigest()
data.append({
'engine_id': query['engine_id'],
'duration': query['duration'],
'sql': format_sql(query['statement']),
'raw_sql': query['statement'],
'hash': hash,
'params': params,
'is_select': is_select,
'context': query['context'],
})
vars = {
'static_path': self.request.static_url(STATIC_PATH),
'root_path': self.request.route_url(ROOT_ROUTE_NAME),
'queries': data,
}
delattr(self.request, 'pdtb_sqla_queries')
return self.render(
'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2', vars,
self.request)
def sql_explain(self):
stmt, params = self.validate()
engine_id = self.request.params["engine_id"]
if not engine_id:
raise HTTPBadRequest("No valid database engine")
engine = getattr(self.request.registry, "pdtb_sqla_engines")[int(engine_id)]()
params = json.loads(params)
if engine.name.startswith("sqlite"):
query = "EXPLAIN QUERY PLAN %s" % stmt
else:
query = "EXPLAIN %s" % stmt
result = engine.execute(query, params)
return {
"result": result.fetchall(),
"headers": result.keys(),
"sql": format_sql(stmt),
"str": str,
"duration": float(self.request.params["duration"]),
}
def _callFUT(self, query):
from pyramid_debugtoolbar.utils import format_sql
return format_sql(query)
def _callFUT(self, query):
from pyramid_debugtoolbar.utils import format_sql
return format_sql(query)
