def sql_select():
statement = request.args['sql']
params = request.args['params']
bind = request.args.get('bind')
bind = bind if bind != '' else None
# Validate hash
hash = hashlib.sha1(current_app.config['SECRET_KEY'] + statement +
params).hexdigest()
if hash != request.args['hash']:
return abort(406)
# Make sure it is a select statement
if not statement.lower().strip().startswith('select'):
return abort(406)
params = json.loads(params)
engine = SQLAlchemy().get_engine(current_app, bind)
result = engine.execute(statement, params)
return g.debug_toolbar.render(
'panels/sqlalchemy_select.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def content(self):
queries = get_queries()
if not queries and not is_available():
return self.render(
"panels/sqlalchemy_error.html",
{
"json_available": json_available,
"sqlalchemy_available": sqlalchemy_available,
"extension_used": extension_used(),
"recording_enabled": recording_enabled(),
},
)
data = []
for query in queries:
data.append({
"duration":
query.duration,
"sql":
format_sql(query.statement, query.parameters),
"signed_query":
dump_query(query.statement, query.parameters),
"context_long":
query.context,
"context":
format_fname(query.context),
})
return self.render("panels/sqlalchemy.html", {"queries": data})
def content(self):
queries = get_debug_queries()
data = []
for query in 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(current_app.config['SECRET_KEY'] +
query.statement + _params).hexdigest()
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'raw_sql': query.statement,
'hash': hash,
'params': _params,
'is_select': is_select,
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def sql_select():
statement = request.args['sql']
params = request.args['params']
# Validate hash
hash = hashlib.sha1(
current_app.config['SECRET_KEY'] + statement + params).hexdigest()
if hash != request.args['hash']:
return abort(406)
# Make sure it is a select statement
if not statement.lower().strip().startswith('select'):
return abort(406)
params = json.loads(params)
engine = SQLAlchemy().get_engine(current_app)
result = engine.execute(statement, params)
return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def content(self):
queries = get_queries()
if not queries and not is_available():
return self.render(
'panels/sqlalchemy_error.html', {
'json_available': json_available,
'sqlalchemy_available': sqlalchemy_available,
'extension_used': extension_used(),
'recording_enabled': recording_enabled(),
})
data = []
for query in queries:
data.append({
'duration':
query.duration,
'sql':
format_sql(query.statement, query.parameters),
'signed_query':
dump_query(query.statement, query.parameters),
'context_long':
query.context,
'context':
format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def sql_explain():
statement = request.args["sql"]
params = request.args["params"]
bind = request.args.get("bind")
bind = bind if bind != "" else None
# Validate hash
hash = hashlib.sha1(current_app.config["SECRET_KEY"] + statement + params).hexdigest()
if hash != request.args["hash"]:
return abort(406)
# Make sure it is a select statement
if not statement.lower().strip().startswith("select"):
return abort(406)
params = json.loads(params)
engine = SQLAlchemy().get_engine(current_app, bind)
if engine.driver == "pysqlite":
query = "EXPLAIN QUERY PLAN %s" % statement
else:
query = "EXPLAIN %s" % statement
result = engine.execute(query, params)
return g.debug_toolbar.render(
"panels/sqlalchemy_explain.html",
{
"result": result.fetchall(),
"headers": result.keys(),
"sql": format_sql(statement, params),
"duration": float(request.args["duration"]),
},
)
def test_format_sql_pygments():
sql = 'select 1'
html = format_sql(sql, {})
assert isinstance(html, Markup)
assert html.startswith('<div')
assert 'select' in html
assert '1' in html
def sql_explain():
statement = request.args['sql']
params = request.args['params']
# Validate hash
hash = hashlib.sha1(current_app.config['SECRET_KEY'] + statement +
params).hexdigest()
if hash != request.args['hash']:
return abort(406)
# Make sure it is a select statement
if not statement.lower().strip().startswith('select'):
return abort(406)
params = json.loads(params)
engine = SQLAlchemy().get_engine(current_app)
if engine.driver == 'pysqlite':
query = 'EXPLAIN QUERY PLAN %s' % statement
else:
query = 'EXPLAIN %s' % statement
result = engine.execute(query, params)
return g.debug_toolbar.render(
'panels/sqlalchemy_explain.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def content(self):
if not json_available or not sqlalchemy_available:
msg = ['Missing required libraries:', '<ul>']
if not json_available:
msg.append('<li>simplejson</li>')
if not sqlalchemy_available:
msg.append('<li>Flask-SQLAlchemy</li>')
msg.append('</ul>')
return '\n'.join(msg)
queries = get_debug_queries()
data = []
for query in queries:
data.append({
'duration':
query.duration,
'sql':
format_sql(query.statement, query.parameters),
'signed_query':
dump_query(query.statement, query.parameters),
'context_long':
query.context,
'context':
format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def content(self):
if not json_available or not sqlalchemy_available:
msg = ['Missing required libraries:', '<ul>']
if not json_available:
msg.append('<li>simplejson</li>')
if not sqlalchemy_available:
msg.append('<li>Flask-SQLAlchemy</li>')
msg.append('</ul>')
return '\n'.join(msg)
queries = get_debug_queries()
data = []
for query in 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(current_app.config['SECRET_KEY'] +
query.statement + _params).hexdigest()
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'raw_sql': query.statement,
'hash': hash,
'params': _params,
'is_select': is_select,
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def test_format_sql_pygments():
sql = 'select 1'
html = format_sql(sql, {})
assert isinstance(html, Markup)
assert html.startswith('<div')
assert 'select' in html
assert '1' in html
def content(self):
queries = get_debug_queries()
data = []
for query in 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(
current_app.config['SECRET_KEY'] +
query.statement + _params).hexdigest()
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'raw_sql': query.statement,
'hash': hash,
'params': _params,
'is_select': is_select,
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', { 'queries': data})
def test_format_sql_pygments_non_ascii():
sql = b"select 'abc \xff xyz'"
html = format_sql(sql, {})
assert isinstance(html, Markup)
assert html.startswith('<div')
assert 'select' in html
assert 'abc' in html
assert 'xyz' in html
def test_format_sql_pygments_non_ascii():
sql = b"select 'abc \xff xyz'"
html = format_sql(sql, {})
assert isinstance(html, Markup)
assert html.startswith('<div')
assert 'select' in html
assert 'abc' in html
assert 'xyz' in html
def sqla_sql_select():
statement, params = load_query(request.args['query'])
engine = SQLADebugPanel._engine
result = engine.execute(statement, params)
template = _jinja_env.get_template('select.html')
return template.render({
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select():
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
result = engine.execute(statement, params)
return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select():
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
result = engine.execute(statement, params)
return g.debug_toolbar.render(
'panels/sqlalchemy_select.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select():
statement = request.args['sql']
params = request.args['params']
params = json.loads(params)
db = SQLAlchemy()
result = db.engine.execute(statement, params)
return render_template('panels/sqlalchemy_select.html', **{
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select():
statement = request.args['sql']
params = request.args['params']
params = json.loads(params)
db = SQLAlchemy()
result = db.engine.execute(statement, params)
return render_template(
'panels/sqlalchemy_select.html', **{
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_explain():
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
if engine.driver == 'pysqlite':
query = 'EXPLAIN QUERY PLAN %s' % statement
else:
query = 'EXPLAIN %s' % statement
result = engine.execute(query, params)
return g.debug_toolbar.render('panels/sqlalchemy_explain.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select(explain=False):
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
if explain:
if engine.driver == 'pysqlite':
statement = 'EXPLAIN QUERY PLAN\n%s' % statement
else:
statement = 'EXPLAIN\n%s' % statement
result = engine.execute(statement, params)
return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sqla_sql_explain():
statement, params = load_query(request.args['query'])
engine = SQLADebugPanel._engine
if engine.driver == 'pysqlite':
query = 'EXPLAIN QUERY PLAN %s' % statement
else:
query = 'EXPLAIN %s' % statement
result = engine.execute(query, params)
template = _jinja_env.get_template('explain.html')
return template.render({
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_analyze():
statement, params = load_query(request.args['query'])
engine = SQLAlchemy().get_engine(current_app)
if engine.driver == 'pysqlite':
query = 'EXPLAIN ANALYZE QUERY PLAN %s' % statement
else:
query = 'EXPLAIN ANALYZE %s' % statement
result = engine.execute(query, params)
return g.debug_toolbar.render(
'panels/sqlalchemy_explain.html', {
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def _after_cursor_execute(cls, conn, cursor, statement, parameters,
context, executemany):
start_time = cls._locals()['QUERY_TIMER']
end_time = time.time()
if 'DEBUG_STATEMENTS' not in cls._locals():
cls._locals()['DEBUG_STATEMENTS'] = []
cls._locals()['DEBUG_STATEMENTS'].append({
'duration':
end_time - start_time,
'sql':
format_sql(statement, parameters),
'signed_query':
dump_query(statement, parameters),
'context_long':
_calling_context(cls.package_names + [current_app.import_name]),
'context':
_calling_context(cls.package_names + [current_app.import_name]),
})
def sql_select(explain=False):
statement, params = load_query(request.args["query"])
engine = SQLAlchemy().get_engine(current_app)
if explain:
if engine.driver == "pysqlite":
statement = "EXPLAIN QUERY PLAN\n%s" % statement
else:
statement = "EXPLAIN\n%s" % statement
result = engine.execute(statement, params)
return g.debug_toolbar.render(
"panels/sqlalchemy_select.html",
{
"result": result.fetchall(),
"headers": result.keys(),
"sql": format_sql(statement, params),
"duration": float(request.args["duration"]),
},
)
def content(self):
queries = get_queries()
if not queries and not is_available():
return self.render('panels/sqlalchemy_error.html', {
'sqlalchemy_available': sqlalchemy_available,
'extension_used': extension_used(),
'recording_enabled': recording_enabled(),
})
data = []
for query in queries:
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'signed_query': dump_query(query.statement, query.parameters),
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def sql_explain():
statement = request.args['sql']
params = request.args['params']
params = json.loads(params)
db = SQLAlchemy()
if db.engine.driver == 'pysqlite':
query = 'EXPLAIN QUERY PLAN %s' % statement
elif db.engine.driver == 'psycopg2':
query = 'EXPLAIN VERBOSE %s' % statement
else:
query = 'EXPLAIN %s' % statement
result = db.engine.execute(query, params)
return render_template('panels/sqlalchemy_explain.html', **{
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_explain():
statement = request.args['sql']
params = request.args['params']
params = json.loads(params)
db = SQLAlchemy()
if db.engine.driver == 'pysqlite':
query = 'EXPLAIN QUERY PLAN %s' % statement
elif db.engine.driver == 'psycopg2':
query = 'EXPLAIN VERBOSE %s' % statement
else:
query = 'EXPLAIN %s' % statement
result = db.engine.execute(query, params)
return render_template(
'panels/sqlalchemy_explain.html', **{
'result': result.fetchall(),
'headers': result.keys(),
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def sql_select(explain=False):
statement, params = load_query(request.args['query'])
database = current_app.extensions.get('peewee').database.obj
if explain:
if isinstance(database, SqliteDatabase):
statement = 'EXPLAIN QUERY PLAN\n%s' % statement
else:
statement = 'EXPLAIN\n%s' % statement
result = database.execute_sql(statement, params)
headers = []
data = list(result.fetchall())
if data:
headers = ['' for _ in range(len(data[0]))]
return g.debug_toolbar.render('panels/sqlalchemy_select.html', {
'result': data,
'headers': headers,
'sql': format_sql(statement, params),
'duration': float(request.args['duration']),
})
def content(self):
if not json_available or not sqlalchemy_available:
msg = ['Missing required libraries:', '<ul>']
if not json_available:
msg.append('<li>simplejson</li>')
if not sqlalchemy_available:
msg.append('<li>Flask-SQLAlchemy</li>')
msg.append('</ul>')
return '\n'.join(msg)
queries = get_debug_queries()
data = []
for query in queries:
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'signed_query': dump_query(query.statement, query.parameters),
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', {'queries': data})
def content(self):
if not json_available or not sqlalchemy_available:
msg = ["Missing required libraries:", "<ul>"]
if not json_available:
msg.append("<li>simplejson</li>")
if not sqlalchemy_available:
msg.append("<li>Flask-SQLAlchemy</li>")
msg.append("</ul>")
return "\n".join(msg)
queries = get_debug_queries()
data = []
for query in 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(current_app.config["SECRET_KEY"] + query.statement + _params).hexdigest()
bind = ""
if hasattr(query, "bind") and query.bind is not None:
bind = query.bind
data.append(
{
"duration": query.duration,
"sql": format_sql(query.statement, query.parameters),
"raw_sql": query.statement,
"hash": hash,
"params": _params,
"is_select": is_select,
"context_long": query.context,
"context": format_fname(query.context),
"bind": bind,
}
)
return self.render("panels/sqlalchemy.html", {"queries": data})
def content(self):
if not json_available or not sqlalchemy_available:
msg = ['Missing required libraries:', '<ul>']
if not json_available:
msg.append('<li>simplejson</li>')
if not sqlalchemy_available:
msg.append('<li>Flask-SQLAlchemy</li>')
msg.append('</ul>')
return '\n'.join(msg)
queries = get_debug_queries()
data = []
for query in 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(
current_app.config['SECRET_KEY'] +
query.statement + _params).hexdigest()
data.append({
'duration': query.duration,
'sql': format_sql(query.statement, query.parameters),
'raw_sql': query.statement,
'hash': hash,
'params': _params,
'is_select': is_select,
'context_long': query.context,
'context': format_fname(query.context)
})
return self.render('panels/sqlalchemy.html', { 'queries': data})
def test_format_sql_no_pygments_escape_html(no_pygments):
sql = 'select x < 1'
formatted = format_sql(sql, {})
assert not isinstance(formatted, Markup)
assert Markup('%s') % formatted == 'select x < 1'
def test_format_sql_no_pygments(no_pygments):
sql = 'select 1'
assert format_sql(sql, {}) == sql
def test_format_sql_no_pygments_non_ascii(no_pygments):
sql = b"select '\xff'"
formatted = format_sql(sql, {})
assert formatted.startswith(u"select '")
def test_format_sql_no_pygments_escape_html(no_pygments):
sql = 'select x < 1'
formatted = format_sql(sql, {})
assert not isinstance(formatted, Markup)
assert Markup('%s') % formatted == 'select x < 1'
def test_format_sql_no_pygments(no_pygments):
sql = 'select 1'
assert format_sql(sql, {}) == sql
def test_format_sql_no_pygments_non_ascii(no_pygments):
sql = b"select '\xff'"
formatted = format_sql(sql, {})
assert formatted.startswith(u"select '")
