def execute_from_file(self, arg, **_): if not arg: message = "Missing required argument, filename." return [(None, None, None, message)] try: with open(os.path.expanduser(arg), encoding="utf-8") as f: query = f.read() except IOError as e: return [(None, None, None, str(e))] if self.destructive_warning and confirm_destructive_query( query) is False: message = "Wise choice. Command execution stopped." return [(None, None, None, message)] return self.sqlexecute.run(query)
def cli( database, dbname, version, prompt, logfile, auto_vertical_output, table, csv, warn, execute, liteclirc, ): """A SQLite terminal client with auto-completion and syntax highlighting. \b Examples: - litecli lite_database """ if version: print("Version:", __version__) sys.exit(0) litecli = LiteCli( prompt=prompt, logfile=logfile, auto_vertical_output=auto_vertical_output, warn=warn, liteclirc=liteclirc, ) # Choose which ever one has a valid value. database = database or dbname litecli.connect(database) litecli.logger.debug("Launch Params: \n" "\tdatabase: %r", database) # --execute argument if execute: try: if csv: litecli.formatter.format_name = "csv" elif not table: litecli.formatter.format_name = "tsv" litecli.run_query(execute) exit(0) except Exception as e: click.secho(str(e), err=True, fg="red") exit(1) if sys.stdin.isatty(): litecli.run_cli() else: stdin = click.get_text_stream("stdin") stdin_text = stdin.read() try: sys.stdin = open("/dev/tty") except (FileNotFoundError, OSError): litecli.logger.warning("Unable to open TTY as stdin.") if (litecli.destructive_warning and confirm_destructive_query(stdin_text) is False): exit(0) try: new_line = True if csv: litecli.formatter.format_name = "csv" elif not table: litecli.formatter.format_name = "tsv" litecli.run_query(stdin_text, new_line=new_line) exit(0) except Exception as e: click.secho(str(e), err=True, fg="red") exit(1)
def one_iteration(text=None): if text is None: try: text = self.prompt_app.prompt() except KeyboardInterrupt: return special.set_expanded_output(False) try: text = self.handle_editor_command(text) except RuntimeError as e: #logger.error("sql: %r, error: %r", text, e) #logger.error("traceback: %r", traceback.format_exc()) self.showerr(e) return if not text.strip(): return if self.destructive_warning: destroy = confirm_destructive_query(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 # Keep track of whether or not the query is mutating. In case # of a multi-statement query, the overall query is considered # mutating if any one of the component statements is mutating mutating = False try: logger.debug("sql: %r", text) special.write_tee(self.get_prompt(self.prompt_format) + text) if self.logfile: self.logfile.write("\n# %s\n" % datetime.now()) self.logfile.write(text) self.logfile.write("\n") successful = False start = time() res = sqlexecute.run(text, DBNAME) self.formatter.query = text successful = True result_count = 0 for title, cur, headers, status in res: logger.debug("headers: %r", headers) logger.debug("rows: %r", cur) logger.debug("status: %r", status) threshold = 1000 if is_select(status) and cur and cur.rowcount > 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 if self.auto_vertical_output: max_width = self.prompt_app.output.get_size().columns else: max_width = None formatted = self.format_output( title, cur, headers, special.is_expanded_output(), max_width) t = time() - start try: if result_count > 0: self.echo("") try: self.output(formatted, status) except KeyboardInterrupt: pass 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: # get last connection id connection_id_to_kill = sqlexecute.connection_id logger.debug("connection id to kill: %r", connection_id_to_kill) # Restart connection to the database sqlexecute.connect() try: for title, cur, headers, status in sqlexecute.run( "kill %s" % connection_id_to_kill): status_str = str(status).lower() if status_str.find("ok") > -1: logger.debug( "cancelled query, connection id: %r, sql: %r", connection_id_to_kill, text, ) self.echo("cancelled query", err=True, fg="red") except Exception as e: self.echo( "Encountered error while cancelling query: {}".format( e), err=True, fg="red", ) except NotImplementedError: self.echo("Not Yet Implemented.", fg="yellow") except OperationalError as e: logger.debug("Exception: %r", e) if e.args[0] in (2003, 2006, 2013): logger.debug("Attempting to reconnect.") self.echo("Reconnecting...", fg="yellow") try: sqlexecute.connect() logger.debug("Reconnected successfully.") one_iteration(text) return # OK to just return, cuz the recursion call runs to the end. except OperationalError as e: logger.debug("Reconnect failed. e: %r", e) self.echo(str(e), err=True, fg="red") # If reconnection failed, don't proceed further. return else: #logger.error("sql: %r, error: %r", text, e) #logger.error("traceback: %r", traceback.format_exc()) self.showerr(e) except Exception as e: #logger.error("sql: %r, error: %r", text, e) #logger.error("traceback: %r", traceback.format_exc()) self.showerr(e) else: if is_dropping_database(text, self.sqlexecute.dbname): self.sqlexecute.dbname = None self.sqlexecute.connect() # Refresh the table names and column names if necessary. if need_completion_refresh(text): self.refresh_completions(reset=need_completion_reset(text)) finally: if self.logfile is False: self.echo("Warning: This query was not logged.", err=True, fg="red") query = Query(text, successful, mutating) self.query_history.append(query)