def execute_file_query(cur, arg, **_): filename = arg if filename: try: with open(filename, encoding='utf-8') as f: query = f.read() for sql in sqlparse.split(query): if not sql: continue _logger.debug("query is [%s]", sql) sql = sql.rstrip(';') destructive_prompt = confirm_destructive_query(sql) if destructive_prompt is False: click.secho("Wise choice!") return elif destructive_prompt is True: click.secho("Your call!") title = '%s' % (sql) cur.execute(sql) if cur.description: headers = [x[0] for x in cur.description] yield (title, cur.fetchall(), headers, None) else: yield (title, None, None, None) except IOError: message = 'Error reading file: %s.' % filename yield (None, None, None, message)
def watch_query(arg, **kwargs): usage = """Syntax: watch [seconds] [-c] query. * seconds: The interval at the query will be repeated, in seconds. By default 5. * -c: Clears the screen between every iteration. """ if not arg: yield (None, None, None, usage) return seconds = 5 clear_screen = False statement = None while statement is None: arg = arg.strip() if not arg: # Oops, we parsed all the arguments without finding a statement yield (None, None, None, usage) return (current_arg, _, arg) = arg.partition(' ') try: seconds = float(current_arg) continue except ValueError: pass if current_arg == '-c': clear_screen = True continue statement = '{0!s} {1!s}'.format(current_arg, arg) destructive_prompt = confirm_destructive_query(statement) if destructive_prompt is False: click.secho("Wise choice!") return elif destructive_prompt is True: click.secho("Your call!") cur = kwargs['cur'] sql_list = [(sql.rstrip(';'), "> {0!s}".format(sql)) for sql in sqlparse.split(statement)] old_pager_enabled = is_pager_enabled() while True: if clear_screen: click.clear() try: # Somewhere in the code the pager its activated after every yield, # so we disable it in every iteration set_pager_enabled(False) for (sql, title) in sql_list: cur.execute(sql) if cur.description: headers = [x[0] for x in cur.description] yield (title, cur.fetchall(), headers, None) else: yield (title, None, None, None) sleep(seconds) except KeyboardInterrupt: # This prints the Ctrl-C character in its own line, which prevents # to print a line with the cursor positioned behind the prompt click.secho("", nl=True) return finally: set_pager_enabled(old_pager_enabled)
def run_query(self, query, new_line=True): """Runs *query*.""" if (self.destructive_warning and confirm_destructive_query(query) is False): message = 'Wise choice. Command execution stopped.' click.echo(message) return results = self.sqlexecute.run(query) for result in results: title, rows, headers, _ = result self.formatter.query = query output = self.format_output(title, rows, headers) for line in output: click.echo(line, nl=new_line)
def one_iteration(): document = self.cli.run() special.set_expanded_output(False) try: document = self.handle_editor_command(self.cli, document) except RuntimeError as e: LOGGER.error("sql: %r, error: %r", document.text, e) LOGGER.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg='red') return if not document.text.strip(): return if self.destructive_warning: destroy = confirm_destructive_query(document.text) if destroy is None: pass # Query was not destructive. Nothing to do here. elif destroy is True: self.echo('Your call!') else: self.echo('Wise choice!') return mutating = False try: LOGGER.debug('sql: %r', document.text) special.write_tee(self.get_prompt(self.prompt) + document.text) successful = False start = time() res = self.sqlexecute.run(document.text) successful = True threshold = 1000 result_count = 0 for title, rows, headers, status in res: if rows and len(rows) > threshold: self.echo( 'The result set has more than {} rows.'.format( threshold), fg='red') if not confirm('Do you want to continue?'): self.echo('Aborted!', err=True, fg='red') break formatted = self.format_output( title, rows, headers, special.is_expanded_output(), None) t = time() - start try: if result_count > 0: self.echo('') try: self.output(formatted, status) except KeyboardInterrupt: pass if special.is_timing_enabled(): self.echo('Time: %0.03fs' % t) except KeyboardInterrupt: pass start = time() result_count += 1 mutating = mutating or is_mutating(status) special.unset_once_if_written() except EOFError as e: raise e except KeyboardInterrupt: pass except NotImplementedError: self.echo('Not Yet Implemented.', fg="yellow") except OperationalError as e: LOGGER.debug("Exception: %r", e) LOGGER.error("sql: %r, error: %r", document.text, e) LOGGER.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg='red') except Exception as e: LOGGER.error("sql: %r, error: %r", document.text, e) LOGGER.error("traceback: %r", traceback.format_exc()) self.echo(str(e), err=True, fg='red') else: # Refresh the table names and column names if necessary. if need_completion_refresh(document.text): LOGGER.debug("=" * 10) self.refresh_completions() query = Query(document.text, successful, mutating) self.query_history.append(query)
def test_confirm_destructive_query_notty(): stdin = click.get_text_stream('stdin') assert stdin.isatty() is False sql = 'drop database foo;' assert confirm_destructive_query(sql) is None