class MyCli(object):
default_prompt = '\\t \\u@\\h:\\d> '
max_len_prompt = 45
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = [
'/etc/my.cnf',
'/etc/mysql/my.cnf',
'/usr/local/etc/my.cnf',
'~/.my.cnf'
]
system_config_files = [
'/etc/myclirc',
]
default_config_file = os.path.join(PACKAGE_ROOT, 'myclirc')
def __init__(self, sqlexecute=None, prompt=None,
logfile=None, defaults_suffix=None, defaults_file=None,
login_path=None, auto_vertical_output=False, warn=None,
myclirc="~/.myclirc"):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
# self.cnf_files is a class variable that stores the list of mysql
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = ([self.default_config_file] + self.system_config_files +
[myclirc])
c = self.config = read_config_files(config_files)
self.multi_line = c['main'].as_bool('multi_line')
self.key_bindings = c['main']['key_bindings']
special.set_timing_enabled(c['main'].as_bool('timing'))
self.formatter = output_formatter.OutputFormatter(
format_name=c['main']['table_format'])
self.syntax_style = c['main']['syntax_style']
self.less_chatty = c['main'].as_bool('less_chatty')
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
c_dest_warning = c['main'].as_bool('destructive_warning')
self.destructive_warning = c_dest_warning if warn is None else warn
self.login_path_as_host = c['main'].as_bool('login_path_as_host')
# read from cli argument or user config file
self.auto_vertical_output = auto_vertical_output or \
c['main'].as_bool('auto_vertical_output')
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, myclirc)
# audit log
if self.logfile is None and 'audit_log' in c['main']:
try:
self.logfile = open(os.path.expanduser(c['main']['audit_log']), 'a')
except (IOError, OSError) as e:
self.output('Error: Unable to open the audit log file. Your queries will not be logged.', err=True, fg='red')
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files, ['prompt'])['prompt']
self.prompt_format = prompt or prompt_cnf or c['main']['prompt'] or \
self.default_prompt
self.prompt_continuation_format = c['main']['prompt_continuation']
self.query_history = []
# Initialize completer.
self.smart_completion = c['main'].as_bool('smart_completion')
self.completer = SQLCompleter(
self.smart_completion,
supported_formats=self.formatter.supported_formats())
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
# Load .mylogin.cnf if it exists.
mylogin_cnf_path = get_mylogin_cnf_path()
if mylogin_cnf_path:
mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path)
if mylogin_cnf_path and mylogin_cnf:
# .mylogin.cnf gets read last, even if defaults_file is specified.
self.cnf_files.append(mylogin_cnf)
elif mylogin_cnf_path and not mylogin_cnf:
# There was an error reading the login path file.
print('Error: Unable to read login path file.')
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_db, 'use',
'\\u', 'Change to a new database.', aliases=('\\u',))
special.register_special_command(self.change_db, 'connect',
'\\r', 'Reconnect to the database. Optional database argument.',
aliases=('\\r', ), case_sensitive=True)
special.register_special_command(self.refresh_completions, 'rehash',
'\\#', 'Refresh auto-completions.', arg_type=NO_QUERY, aliases=('\\#',))
special.register_special_command(self.change_table_format, 'tableformat',
'\\T', 'Change Table Type.', aliases=('\\T',), case_sensitive=True)
special.register_special_command(self.execute_from_file, 'source', '\\. filename',
'Execute commands from file.', aliases=('\\.',))
special.register_special_command(self.change_prompt_format, 'prompt',
'\\R', 'Change prompt format.', aliases=('\\R',), case_sensitive=True)
def change_table_format(self, arg, **_):
try:
self.formatter.set_format_name(arg)
yield (None, None, None,
'Changed table type to {}'.format(arg))
except ValueError:
msg = 'Table type {} not yet implemented. Allowed types:'.format(
arg)
for table_type in self.formatter.supported_formats():
msg += "\n\t{}".format(table_type)
yield (None, None, None, msg)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user))
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 change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = 'Missing required argument, format.'
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
# Disable logging if value is NONE by switching to a no-op handler
# Set log level to a high value so it doesn't even waste cycles getting called.
if log_level.upper() == "NONE":
handler = NullHandler()
log_level = "CRITICAL"
else:
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('mycli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
logging.captureWarnings(True)
root_logger.debug('Initializing mycli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri, local_infile=None, ssl=None):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.username, uri.password, uri.hostname,
uri.port, local_infile=local_infile, ssl=ssl)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ['client']
if self.login_path and self.login_path != 'client':
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return {x: get(x) for x in keys}
def merge_ssl_with_cnf(self, ssl, cnf):
"""Merge SSL configuration dict with cnf dict"""
merged = {}
merged.update(ssl)
prefix = 'ssl-'
for k, v in cnf.items():
# skip unrelated options
if not k.startswith(prefix):
continue
if v is None:
continue
# special case because PyMySQL argument is significantly different
# from commandline
if k == 'ssl-verify-server-cert':
merged['check_hostname'] = v
else:
# use argument name just strip "ssl-" prefix
arg = k[len(prefix):]
merged[arg] = v
return merged
def connect(self, database='', user='', passwd='', host='', port='',
socket='', charset='', local_infile='', ssl=''):
cnf = {'database': None,
'user': None,
'password': None,
'host': None,
'port': None,
'socket': None,
'default-character-set': None,
'local-infile': None,
'loose-local-infile': None,
'ssl-ca': None,
'ssl-cert': None,
'ssl-key': None,
'ssl-cipher': None,
'ssl-verify-serer-cert': None,
}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf['database']
if port or host:
socket = ''
else:
socket = socket or cnf['socket']
user = user or cnf['user'] or os.getenv('USER')
host = host or cnf['host'] or 'localhost'
port = port or cnf['port'] or 3306
ssl = ssl or {}
try:
port = int(port)
except ValueError as e:
self.output("Error: Invalid port number: '{0}'.".format(port),
err=True, fg='red')
exit(1)
passwd = passwd or cnf['password']
charset = charset or cnf['default-character-set'] or 'utf8'
# Favor whichever local_infile option is set.
for local_infile_option in (local_infile, cnf['local-infile'],
cnf['loose-local-infile'], False):
try:
local_infile = str_to_bool(local_infile_option)
break
except (TypeError, ValueError):
pass
ssl = self.merge_ssl_with_cnf(ssl, cnf)
# prune lone check_hostname=False
if not any(v for v in ssl.values()):
ssl = None
# Connect to the database.
try:
try:
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset, local_infile, ssl)
except OperationalError as e:
if ('Access denied for user' in e.args[1]):
passwd = click.prompt('Password', hide_input=True,
show_default=False, type=str)
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset, local_infile, ssl)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
exit(1)
self.sqlexecute = sqlexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
# FIXME: using application.pre_run_callables like this here is not the best solution.
# It's internal api of prompt_toolkit that may change. This was added to fix
# https://github.com/dbcli/pgcli/issues/668. We may find a better way to do it in the future.
saved_callables = cli.application.pre_run_callables
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql, cursor_position=len(sql))
cli.application.pre_run_callables = []
document = cli.run()
continue
cli.application.pre_run_callables = saved_callables
return document
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
self.configure_pager()
if self.smart_completion:
self.refresh_completions()
author_file = os.path.join(PACKAGE_ROOT, 'AUTHORS')
sponsor_file = os.path.join(PACKAGE_ROOT, 'SPONSORS')
key_binding_manager = mycli_bindings()
if not self.less_chatty:
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -', thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
prompt = self.get_prompt(self.prompt_format)
if self.prompt_format == self.default_prompt and len(prompt) > self.max_len_prompt:
prompt = self.get_prompt('\\d> ')
return [(Token.Prompt, prompt)]
def get_continuation_tokens(cli, width):
continuation_prompt = self.get_prompt(self.prompt_continuation_format)
return [(Token.Continuation, ' ' * (width - len(continuation_prompt)) + continuation_prompt)]
def one_iteration(document=None):
if document is None:
document = self.cli.run()
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
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.output(str(e), err=True, fg='red')
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.output('Your call!')
else:
self.output('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', document.text)
special.write_tee(self.get_prompt(self.prompt_format) + document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
successful = True
output = []
total = 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.output('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
self.output("Aborted!", err=True, fg='red')
break
if self.auto_vertical_output:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = self.format_output(title, cur, headers, status,
special.is_expanded_output(),
max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
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, document.text)
self.output("cancelled query", err=True, fg='red')
except Exception as e:
self.output('Encountered error while cancelling query: %s' % str(e), err=True, fg='red')
except NotImplementedError:
self.output('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.output('Reconnecting...', fg='yellow')
try:
sqlexecute.connect()
logger.debug('Reconnected successfully.')
one_iteration(document)
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.output(str(e), err=True, fg='red')
return # If reconnection failed, don't proceed further.
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(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.output(str(e), err=True, fg='red')
else:
try:
special.write_tee('\n'.join(output))
if special.is_pager_enabled():
self.output_via_pager('\n'.join(output))
else:
self.output('\n'.join(output))
except KeyboardInterrupt:
pass
if special.is_timing_enabled():
self.output('Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.output("Warning: This query was not logged.", err=True, fg='red')
query = Query(document.text, successful, mutating)
self.query_history.append(query)
get_toolbar_tokens = create_toolbar_tokens_func(self.completion_refresher.is_refreshing)
layout = create_prompt_layout(lexer=MyCliLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
with self._completer_lock:
buf = CLIBuffer(always_multiline=self.multi_line, completer=self.completer,
history=FileHistory(os.path.expanduser(os.environ.get('MYCLI_HISTFILE', '~/.mycli-history'))),
complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT)
if self.key_bindings == 'vi':
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
application = Application(style=style_factory(self.syntax_style, self.cli_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
editing_mode=editing_mode,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
one_iteration()
except EOFError:
special.close_tee()
if not self.less_chatty:
self.output('Goodbye!')
def output(self, text, **kwargs):
special.write_tee(text)
if self.logfile:
self.logfile.write(utf8tounicode(text))
self.logfile.write('\n')
click.secho(text, **kwargs)
def output_via_pager(self, text):
if self.logfile:
self.logfile.write(text)
self.logfile.write('\n')
click.echo_via_pager(text)
def configure_pager(self):
# Provide sane defaults for less if they are empty.
if not os.environ.get('LESS'):
os.environ['LESS'] = '-RXF'
cnf = self.read_my_cnf_files(self.cnf_files, ['pager', 'skip-pager'])
if cnf['pager']:
special.set_pager(cnf['pager'])
if cnf['skip-pager']:
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(
self.sqlexecute, self._on_completions_refreshed,
{'smart_completion': self.smart_completion,
'supported_formats': self.formatter.supported_formats()})
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When mycli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
host = self.login_path if self.login_path and self.login_path_as_host else sqlexecute.host
string = string.replace('\\u', sqlexecute.user or '(none)')
string = string.replace('\\h', host or '(none)')
string = string.replace('\\d', sqlexecute.dbname or '(none)')
string = string.replace('\\t', sqlexecute.server_type()[0] or 'mycli')
string = string.replace('\\n', "\n")
string = string.replace('\\D', datetime.now().strftime('%a %b %d %H:%M:%S %Y'))
string = string.replace('\\p', str(sqlexecute.port))
string = string.replace('\\_', ' ')
return string
def run_query(self, query, new_line=True):
"""Runs *query*."""
results = self.sqlexecute.run(query)
for result in results:
title, cur, headers, status = result
output = self.format_output(title, cur, headers, None)
for line in output:
click.echo(line, nl=new_line)
def format_output(self, title, cur, headers, status, expanded=False,
max_width=None):
expanded = expanded or self.formatter.get_format_name() == 'expanded'
output = []
if title: # Only print the title if it's not None.
output.append(title)
if cur:
rows = list(cur)
formatted = self.formatter.format_output(
rows, headers, format_name='expanded' if expanded else None)
if (not expanded and max_width and rows and
content_exceeds_width(rows[0], max_width) and headers):
formatted = self.formatter.format_output(
rows, headers, format_name='expanded')
output.append(formatted)
if status: # Only print the status if it's not None.
output.append(status)
return output
class PGCli(object):
def __init__(self,
force_passwd_prompt=False,
never_passwd_prompt=False,
pgexecute=None,
pgclirc_file=None):
self.force_passwd_prompt = force_passwd_prompt
self.never_passwd_prompt = never_passwd_prompt
self.pgexecute = pgexecute
from pgcli import __file__ as package_root
package_root = os.path.dirname(package_root)
default_config = os.path.join(package_root, 'pgclirc')
write_default_config(default_config, pgclirc_file)
self.pgspecial = PGSpecial()
# Load config.
c = self.config = load_config(pgclirc_file, default_config)
self.multi_line = c['main'].as_bool('multi_line')
self.vi_mode = c['main'].as_bool('vi')
self.pgspecial.timing_enabled = c['main'].as_bool('timing')
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
on_error_modes = {'STOP': ON_ERROR_STOP, 'RESUME': ON_ERROR_RESUME}
self.on_error = on_error_modes[c['main']['on_error'].upper()]
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
self.query_history = []
# Initialize completer
smart_completion = c['main'].as_bool('smart_completion')
completer = PGCompleter(smart_completion, pgspecial=self.pgspecial)
self.completer = completer
self._completer_lock = threading.Lock()
self.register_special_commands()
self.cli = None
def register_special_commands(self):
self.pgspecial.register(self.change_db,
'\\c',
'\\c[onnect] database_name',
'Change to a new database.',
aliases=('use', '\\connect', 'USE'))
self.pgspecial.register(self.refresh_completions,
'\\#',
'\\#',
'Refresh auto-completions.',
arg_type=NO_QUERY)
self.pgspecial.register(self.refresh_completions,
'\\refresh',
'\\refresh',
'Refresh auto-completions.',
arg_type=NO_QUERY)
self.pgspecial.register(self.execute_from_file, '\\i', '\\i filename',
'Execute commands from file.')
def change_db(self, pattern, **_):
if pattern:
db = pattern[1:-1] if pattern[0] == pattern[-1] == '"' else pattern
self.pgexecute.connect(database=db)
else:
self.pgexecute.connect()
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.pgexecute.dbname, self.pgexecute.user))
def execute_from_file(self, pattern, **_):
if not pattern:
message = '\\i: missing required argument'
return [(None, None, None, message)]
try:
with open(os.path.expanduser(pattern), encoding='utf-8') as f:
query = f.read()
except IOError as e:
return [(None, None, None, str(e))]
return self.pgexecute.run(query,
self.pgspecial,
on_error=self.on_error)
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('pgcli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
root_logger.debug('Initializing pgcli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_dsn(self, dsn):
self.connect(dsn=dsn)
def connect_uri(self, uri):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.hostname, uri.username, uri.port,
uri.password)
def connect(self,
database='',
host='',
user='',
port='',
passwd='',
dsn=''):
# Connect to the database.
if not user:
user = getuser()
if not database:
database = user
# If password prompt is not forced but no password is provided, try
# getting it from environment variable.
if not self.force_passwd_prompt and not passwd:
passwd = os.environ.get('PGPASSWORD', '')
# Prompt for a password immediately if requested via the -W flag. This
# avoids wasting time trying to connect to the database and catching a
# no-password exception.
# If we successfully parsed a password from a URI, there's no need to
# prompt for it, even with the -W flag
if self.force_passwd_prompt and not passwd:
passwd = click.prompt('Password',
hide_input=True,
show_default=False,
type=str)
# Prompt for a password after 1st attempt to connect without a password
# fails. Don't prompt if the -w flag is supplied
auto_passwd_prompt = not passwd and not self.never_passwd_prompt
# Attempt to connect to the database.
# Note that passwd may be empty on the first attempt. If connection
# fails because of a missing password, but we're allowed to prompt for
# a password (no -w flag), prompt for a passwd and try again.
try:
try:
pgexecute = PGExecute(database, user, passwd, host, port, dsn)
except OperationalError as e:
if ('no password supplied' in utf8tounicode(e.args[0])
and auto_passwd_prompt):
passwd = click.prompt('Password',
hide_input=True,
show_default=False,
type=str)
pgexecute = PGExecute(database, user, passwd, host, port,
dsn)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
exit(1)
self.pgexecute = pgexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql,
cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
pgexecute = self.pgexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.refresh_completions()
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = pgcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/pgcli')
print('Mail: https://groups.google.com/forum/#!forum/pgcli')
print('Home: http://pgcli.com')
def prompt_tokens(cli):
return [(Token.Prompt, '%s> ' % pgexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=[
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = PGBuffer(always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(
os.path.expanduser(history_file)),
complete_while_typing=Always())
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the pgexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the pgexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
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())
click.secho(str(e), err=True, fg='red')
continue
# 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', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in pgexecute.run(). Which causes
# finally clause to fail.
res = []
# Run the query.
start = time()
res = pgexecute.run(document.text,
self.pgspecial,
on_error=self.on_error)
output = []
total = 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):
click.secho(
'The result set has more than %s rows.' %
threshold,
fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
if self.pgspecial.auto_expand:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(
title, cur, headers, status, self.table_format,
self.pgspecial.expanded_output, max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
pgexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
reconnect = True
if ('server closed the connection'
in utf8tounicode(e.args[0])):
reconnect = click.prompt(
'Connection reset. Reconnect (Y/n)',
show_default=False,
type=bool,
default=True)
if reconnect:
try:
pgexecute.connect()
click.secho(
'Reconnected!\nTry the command again.',
fg='green')
except OperationalError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(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())
click.secho(str(e), err=True, fg='red')
else:
successful = True
try:
click.echo_via_pager('\n'.join(output))
except KeyboardInterrupt:
pass
if self.pgspecial.timing_enabled:
print('Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
need_completion_reset(document.text))
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(
pgexecute.search_path())
logger.debug('Search path: %r',
self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def adjust_less_opts(self):
less_opts = os.environ.get('LESS', '')
self.logger.debug('Original value for LESS env var: %r', less_opts)
os.environ['LESS'] = '-SRXF'
return less_opts
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.pgexecute, self.pgspecial,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When pgcli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
class MyCli(object):
default_prompt = '\\t \\u@\\h:\\d> '
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = [
'/etc/my.cnf',
'/etc/mysql/my.cnf',
'/usr/local/etc/my.cnf',
'~/.my.cnf'
]
system_config_files = [
'/etc/myclirc',
]
default_config_file = os.path.join(PACKAGE_ROOT, 'myclirc')
user_config_file = '~/.myclirc'
def __init__(self, sqlexecute=None, prompt=None,
logfile=None, defaults_suffix=None, defaults_file=None,
login_path=None, auto_vertical_output=False):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
self.auto_vertical_output = auto_vertical_output
# self.cnf_files is a class variable that stores the list of mysql
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = ([self.default_config_file] + self.system_config_files +
[self.user_config_file])
c = self.config = read_config_files(config_files)
self.multi_line = c['main'].as_bool('multi_line')
self.destructive_warning = c['main'].as_bool('destructive_warning')
self.key_bindings = c['main']['key_bindings']
special.set_timing_enabled(c['main'].as_bool('timing'))
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, self.user_config_file)
# audit log
if self.logfile is None and 'audit_log' in c['main']:
try:
self.logfile = open(os.path.expanduser(c['main']['audit_log']), 'a')
except (IOError, OSError) as e:
self.output('Error: Unable to open the audit log file. Your queries will not be logged.', err=True, fg='red')
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files, ['prompt'])['prompt']
self.prompt_format = prompt or prompt_cnf or c['main']['prompt'] or \
self.default_prompt
self.query_history = []
# Initialize completer.
smart_completion = c['main'].as_bool('smart_completion')
self.completer = SQLCompleter(smart_completion)
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
# Load .mylogin.cnf if it exists.
mylogin_cnf_path = get_mylogin_cnf_path()
if mylogin_cnf_path:
try:
mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path)
if mylogin_cnf_path and mylogin_cnf:
# .mylogin.cnf gets read last, even if defaults_file is specified.
self.cnf_files.append(mylogin_cnf)
elif mylogin_cnf_path and not mylogin_cnf:
# There was an error reading the login path file.
print('Error: Unable to read login path file.')
except CryptoError:
click.secho('Warning: .mylogin.cnf was not read: pycrypto '
'module is not available.')
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_db, 'use',
'\\u', 'Change to a new database.', aliases=('\\u',))
special.register_special_command(self.change_db, 'connect',
'\\r', 'Reconnect to the database. Optional database argument.',
aliases=('\\r', ), case_sensitive=True)
special.register_special_command(self.refresh_completions, 'rehash',
'\\#', 'Refresh auto-completions.', arg_type=NO_QUERY, aliases=('\\#',))
special.register_special_command(self.change_table_format, 'tableformat',
'\\T', 'Change Table Type.', aliases=('\\T',), case_sensitive=True)
special.register_special_command(self.execute_from_file, 'source', '\\. filename',
'Execute commands from file.', aliases=('\\.',))
special.register_special_command(self.change_prompt_format, 'prompt',
'\\R', 'Change prompt format.', aliases=('\\R',), case_sensitive=True)
def change_table_format(self, arg, **_):
if not arg in table_formats():
msg = "Table type %s not yet implemented. Allowed types:" % arg
for table_type in table_formats():
msg += "\n\t%s" % table_type
yield (None, None, None, msg)
else:
self.table_format = arg
yield (None, None, None, "Changed table Type to %s" % self.table_format)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user))
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))]
return self.sqlexecute.run(query)
def change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = 'Missing required argument, format.'
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('mycli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
logging.captureWarnings(True)
root_logger.debug('Initializing mycli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri, local_infile=None):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.username, uri.password, uri.hostname,
uri.port, local_infile=local_infile)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ['client']
if self.login_path and self.login_path != 'client':
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return dict([(x, get(x)) for x in keys])
def connect(self, database='', user='', passwd='', host='', port='',
socket='', charset='', local_infile=''):
cnf = {'database': None,
'user': None,
'password': None,
'host': None,
'port': None,
'socket': None,
'default-character-set': None,
'local-infile': None,
'loose-local-infile': None}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf['database']
if port or host:
socket = ''
else:
socket = socket or cnf['socket']
user = user or cnf['user'] or os.getenv('USER')
host = host or cnf['host'] or 'localhost'
port = port or cnf['port'] or 3306
try:
port = int(port)
except ValueError as e:
self.output("Error: Invalid port number: '{0}'.".format(port),
err=True, fg='red')
exit(1)
passwd = passwd or cnf['password']
charset = charset or cnf['default-character-set'] or 'utf8'
# Favor whichever local_infile option is set.
for local_infile_option in (local_infile, cnf['local-infile'],
cnf['loose-local-infile'], False):
try:
local_infile = str_to_bool(local_infile_option)
break
except (TypeError, ValueError):
pass
# Connect to the database.
try:
try:
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset, local_infile)
except OperationalError as e:
if ('Access denied for user' in e.args[1]):
passwd = click.prompt('Password', hide_input=True,
show_default=False, type=str)
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset, local_infile)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
exit(1)
self.sqlexecute = sqlexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql, cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
self.configure_pager()
self.refresh_completions()
def set_key_bindings(value):
if value not in ('emacs', 'vi'):
value = 'emacs'
self.key_bindings = value
project_root = os.path.dirname(PACKAGE_ROOT)
author_file = os.path.join(project_root, 'AUTHORS')
sponsor_file = os.path.join(project_root, 'SPONSORS')
key_binding_manager = mycli_bindings(get_key_bindings=lambda: self.key_bindings,
set_key_bindings=set_key_bindings)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -', thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.key_bindings,
self.completion_refresher.is_refreshing)
layout = create_prompt_layout(lexer=MyCliLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
with self._completer_lock:
buf = CLIBuffer(always_multiline=self.multi_line, completer=self.completer,
history=FileHistory(os.path.expanduser('~/.mycli-history')),
complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT)
application = Application(style=style_factory(self.syntax_style, self.cli_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
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.output(str(e), err=True, fg='red')
continue
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.output('Your call!')
else:
self.output('Wise choice!')
continue
# 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', document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
successful = True
output = []
total = 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.output('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
self.output("Aborted!", err=True, fg='red')
break
if self.auto_vertical_output:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(title, cur, headers,
status, self.table_format,
special.is_expanded_output(), max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except UnicodeDecodeError as e:
import pymysql
if pymysql.VERSION < ('0', '6', '7'):
message = ('You are running an older version of pymysql.\n'
'Please upgrade to 0.6.7 or above to view binary data.\n'
'Try \'pip install -U pymysql\'.')
self.output(message)
else:
raise e
except KeyboardInterrupt:
# Restart connection to the database
sqlexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
self.output("cancelled query", err=True, fg='red')
except NotImplementedError:
self.output('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
logger.debug("Exception: %r", e)
reconnect = True
if (e.args[0] in (2003, 2006, 2013)):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
logger.debug('Attempting to reconnect.')
try:
sqlexecute.connect()
logger.debug('Reconnected successfully.')
self.output('Reconnected!\nTry the command again.', fg='green')
except OperationalError as e:
logger.debug('Reconnect failed. e: %r', e)
self.output(str(e), err=True, fg='red')
continue # If reconnection failed, don't proceed further.
else: # If user chooses not to reconnect, don't proceed further.
continue
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(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.output(str(e), err=True, fg='red')
else:
try:
if special.is_pager_enabled():
self.output_via_pager('\n'.join(output))
else:
self.output('\n'.join(output))
except KeyboardInterrupt:
pass
if special.is_timing_enabled():
self.output('Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.output("Warning: This query was not logged.", err=True, fg='red')
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
self.output('Goodbye!')
def output(self, text, **kwargs):
if self.logfile:
self.logfile.write(utf8tounicode(text))
self.logfile.write('\n')
click.secho(text, **kwargs)
def output_via_pager(self, text):
if self.logfile:
self.logfile.write(text)
self.logfile.write('\n')
click.echo_via_pager(text)
def configure_pager(self):
# Provide sane defaults for less.
os.environ['LESS'] = '-SRXF'
cnf = self.read_my_cnf_files(self.cnf_files, ['pager', 'skip-pager'])
if cnf['pager']:
special.set_pager(cnf['pager'])
if cnf['skip-pager']:
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.sqlexecute,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When mycli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
string = string.replace('\\u', sqlexecute.user or '(none)')
string = string.replace('\\h', sqlexecute.host or '(none)')
string = string.replace('\\d', sqlexecute.dbname or '(none)')
string = string.replace('\\t', sqlexecute.server_type()[0] or 'mycli')
string = string.replace('\\n', "\n")
return string
class PythonCommandLineInterface(object):
def __init__(
self,
eventloop,
get_globals=None,
get_locals=None,
stdin=None,
stdout=None,
vi_mode=False,
history_filename=None,
style=PythonStyle,
# For internal use.
_completer=None,
_validator=None,
_lexer=None,
_python_prompt_control=None,
_extra_buffers=None,
_extra_buffer_processors=None,
_extra_sidebars=None):
self.settings = PythonCLISettings()
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self.completer = _completer or PythonCompleter(self.get_globals,
self.get_locals)
self.validator = _validator or PythonValidator()
self.history = FileHistory(
history_filename) if history_filename else History()
self.python_prompt_control = _python_prompt_control or PythonPrompt(
self.settings)
self._extra_sidebars = _extra_sidebars or []
self._extra_buffer_processors = _extra_buffer_processors or []
self._lexer = _lexer or PythonLexer
# Use a KeyBindingManager for loading the key bindings.
self.key_bindings_manager = KeyBindingManager(
enable_vi_mode=vi_mode,
enable_open_in_editor=True,
enable_system_prompt=True)
load_python_bindings(self.key_bindings_manager, self.settings)
self.get_signatures_thread_running = False
buffers = {
'default': self._create_python_buffer(),
'docstring': Buffer(), # XXX: make docstring read only.
}
buffers.update(_extra_buffers or {})
self.cli = CommandLineInterface(
eventloop=eventloop,
style=style,
key_bindings_registry=self.key_bindings_manager.registry,
buffers=buffers,
paste_mode=Condition(lambda cli: self.settings.paste_mode),
layout=self._create_layout(),
on_abort=AbortAction.RETRY,
on_exit=AbortAction.RAISE_EXCEPTION)
def on_input_timeout():
"""
When there is no input activity,
in another thread, get the signature of the current code.
"""
if self.cli.focus_stack.current != 'default':
return
# Never run multiple get-signature threads.
if self.get_signatures_thread_running:
return
self.get_signatures_thread_running = True
buffer = self.cli.current_buffer
document = buffer.document
def run():
script = get_jedi_script_from_document(document,
self.get_locals(),
self.get_globals())
# Show signatures in help text.
if script:
try:
signatures = script.call_signatures()
except ValueError:
# e.g. in case of an invalid \\x escape.
signatures = []
except Exception:
# Sometimes we still get an exception (TypeError), because
# of probably bugs in jedi. We can silence them.
# See: https://github.com/davidhalter/jedi/issues/492
signatures = []
else:
signatures = []
self.get_signatures_thread_running = False
# Set signatures and redraw if the text didn't change in the
# meantime. Otherwise request new signatures.
if buffer.text == document.text:
self.settings.signatures = signatures
# Set docstring in docstring buffer.
if signatures:
string = signatures[0].docstring()
if not isinstance(string, six.text_type):
string = string.decode('utf-8')
self.cli.buffers['docstring'].reset(
initial_document=Document(string,
cursor_position=0))
else:
self.cli.buffers['docstring'].reset()
self.cli.request_redraw()
else:
on_input_timeout()
self.cli.eventloop.run_in_executor(run)
def reset():
self.key_bindings_manager.reset()
self.settings.signatures = []
self.cli.onReset += reset
self.cli.onInputTimeout += on_input_timeout
def _create_layout(self):
"""
Generate new layout.
"""
return create_layout(
self.settings,
self.key_bindings_manager,
self.python_prompt_control,
lexer=self._lexer,
extra_buffer_processors=self._extra_buffer_processors,
extra_sidebars=self._extra_sidebars)
def _create_python_buffer(self):
def is_buffer_multiline():
return (self.settings.paste_mode
or document_is_multiline_python(b.document))
b = Buffer(is_multiline=Condition(is_buffer_multiline),
complete_while_typing=Condition(
lambda: self.settings.complete_while_typing),
enable_history_search=Always(),
tempfile_suffix='.py',
history=self.history,
completer=self.completer,
validator=self.validator)
return b
class MyCli(object):
default_prompt = '\\t \\u@\\h:\\d> '
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = [
'/etc/my.cnf',
'/etc/mysql/my.cnf',
'/usr/local/etc/my.cnf',
'~/.my.cnf'
]
system_config_files = [
'/etc/myclirc',
]
default_config_file = os.path.join(PACKAGE_ROOT, 'myclirc')
user_config_file = '~/.myclirc'
def __init__(self, sqlexecute=None, prompt=None,
logfile=None, defaults_suffix=None, defaults_file=None,
login_path=None, auto_vertical_output=False):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
self.auto_vertical_output = auto_vertical_output
# self.cnf_files is a class variable that stores the list of mysql
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = ([self.default_config_file] + self.system_config_files +
[self.user_config_file])
c = self.config = read_config_files(config_files)
self.multi_line = c['main'].as_bool('multi_line')
self.destructive_warning = c['main'].as_bool('destructive_warning')
self.key_bindings = c['main']['key_bindings']
special.set_timing_enabled(c['main'].as_bool('timing'))
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, self.user_config_file)
# audit log
if self.logfile is None and 'audit_log' in c['main']:
try:
self.logfile = open(os.path.expanduser(c['main']['audit_log']), 'a')
except (IOError, OSError) as e:
self.output('Error: Unable to open the audit log file. Your queries will not be logged.', err=True, fg='red')
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files, ['prompt'])['prompt']
self.prompt_format = prompt or prompt_cnf or c['main']['prompt'] or \
self.default_prompt
self.query_history = []
# Initialize completer.
smart_completion = c['main'].as_bool('smart_completion')
self.completer = SQLCompleter(smart_completion)
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
# Load .mylogin.cnf if it exists.
mylogin_cnf_path = get_mylogin_cnf_path()
if mylogin_cnf_path:
try:
mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path)
if mylogin_cnf_path and mylogin_cnf:
# .mylogin.cnf gets read last, even if defaults_file is specified.
self.cnf_files.append(mylogin_cnf)
elif mylogin_cnf_path and not mylogin_cnf:
# There was an error reading the login path file.
print('Error: Unable to read login path file.')
except CryptoError:
click.secho('Warning: .mylogin.cnf was not read: pycrypto '
'module is not available.')
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_db, 'use',
'\\u', 'Change to a new database.', aliases=('\\u',))
special.register_special_command(self.change_db, 'connect',
'\\r', 'Reconnect to the database. Optional database argument.',
aliases=('\\r', ), case_sensitive=True)
special.register_special_command(self.refresh_completions, 'rehash',
'\\#', 'Refresh auto-completions.', arg_type=NO_QUERY, aliases=('\\#',))
special.register_special_command(self.change_table_format, 'tableformat',
'\\T', 'Change Table Type.', aliases=('\\T',), case_sensitive=True)
special.register_special_command(self.execute_from_file, 'source', '\\. filename',
'Execute commands from file.', aliases=('\\.',))
special.register_special_command(self.change_prompt_format, 'prompt',
'\\R', 'Change prompt format.', aliases=('\\R',), case_sensitive=True)
def change_table_format(self, arg, **_):
if not arg in table_formats():
msg = "Table type %s not yet implemented. Allowed types:" % arg
for table_type in table_formats():
msg += "\n\t%s" % table_type
yield (None, None, None, msg)
else:
self.table_format = arg
yield (None, None, None, "Changed table Type to %s" % self.table_format)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user))
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))]
return self.sqlexecute.run(query)
def change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = 'Missing required argument, format.'
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('mycli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
logging.captureWarnings(True)
root_logger.debug('Initializing mycli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.username, uri.password, uri.hostname,
uri.port)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ['client']
if self.login_path and self.login_path != 'client':
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return dict([(x, get(x)) for x in keys])
def connect(self, database='', user='', passwd='', host='', port='',
socket='', charset=''):
cnf = {'database': None,
'user': None,
'password': None,
'host': None,
'port': None,
'socket': None,
'default-character-set': None}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf['database']
if port or host:
socket = ''
else:
socket = socket or cnf['socket']
user = user or cnf['user'] or os.getenv('USER')
host = host or cnf['host'] or 'localhost'
port = port or cnf['port'] or 3306
try:
port = int(port)
except ValueError as e:
self.output("Error: Invalid port number: '{0}'.".format(port),
err=True, fg='red')
exit(1)
passwd = passwd or cnf['password']
charset = charset or cnf['default-character-set'] or 'utf8'
# Connect to the database.
try:
try:
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset)
except OperationalError as e:
if ('Access denied for user' in e.args[1]):
passwd = click.prompt('Password', hide_input=True,
show_default=False, type=str)
sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg='red')
exit(1)
self.sqlexecute = sqlexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql, cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.set_pager_from_config()
self.refresh_completions()
def set_key_bindings(value):
if value not in ('emacs', 'vi'):
value = 'emacs'
self.key_bindings = value
project_root = os.path.dirname(PACKAGE_ROOT)
author_file = os.path.join(project_root, 'AUTHORS')
sponsor_file = os.path.join(project_root, 'SPONSORS')
key_binding_manager = mycli_bindings(get_key_bindings=lambda: self.key_bindings,
set_key_bindings=set_key_bindings)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -', thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.key_bindings,
self.completion_refresher.is_refreshing)
layout = create_prompt_layout(lexer=MyCliLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
with self._completer_lock:
buf = CLIBuffer(always_multiline=self.multi_line, completer=self.completer,
history=FileHistory(os.path.expanduser('~/.mycli-history')),
complete_while_typing=Always(), accept_action=AcceptAction.RETURN_DOCUMENT)
application = Application(style=style_factory(self.syntax_style, self.cli_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
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.output(str(e), err=True, fg='red')
continue
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.output('Your call!')
else:
self.output('Wise choice!')
continue
# 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', document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
successful = True
output = []
total = 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.output('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
self.output("Aborted!", err=True, fg='red')
break
if self.auto_vertical_output:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(title, cur, headers,
status, self.table_format,
special.is_expanded_output(), max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except UnicodeDecodeError as e:
import pymysql
if pymysql.VERSION < ('0', '6', '7'):
message = ('You are running an older version of pymysql.\n'
'Please upgrade to 0.6.7 or above to view binary data.\n'
'Try \'pip install -U pymysql\'.')
self.output(message)
else:
raise e
except KeyboardInterrupt:
# Restart connection to the database
sqlexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
self.output("cancelled query", err=True, fg='red')
except NotImplementedError:
self.output('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
logger.debug("Exception: %r", e)
reconnect = True
if (e.args[0] in (2003, 2006, 2013)):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
logger.debug('Attempting to reconnect.')
try:
sqlexecute.connect()
logger.debug('Reconnected successfully.')
self.output('Reconnected!\nTry the command again.', fg='green')
except OperationalError as e:
logger.debug('Reconnect failed. e: %r', e)
self.output(str(e), err=True, fg='red')
continue # If reconnection failed, don't proceed further.
else: # If user chooses not to reconnect, don't proceed further.
continue
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(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.output(str(e), err=True, fg='red')
else:
try:
if special.is_pager_enabled():
self.output_via_pager('\n'.join(output))
else:
self.output('\n'.join(output))
except KeyboardInterrupt:
pass
if special.is_timing_enabled():
self.output('Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.output("Warning: This query was not logged.", err=True, fg='red')
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
self.output('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
os.environ['PAGER'] = special.get_original_pager()
def output(self, text, **kwargs):
if self.logfile:
self.logfile.write(utf8tounicode(text))
self.logfile.write('\n')
click.secho(text, **kwargs)
def output_via_pager(self, text):
if self.logfile:
self.logfile.write(text)
self.logfile.write('\n')
click.echo_via_pager(text)
def adjust_less_opts(self):
less_opts = os.environ.get('LESS', '')
self.logger.debug('Original value for LESS env var: %r', less_opts)
os.environ['LESS'] = '-SRXF'
return less_opts
def set_pager_from_config(self):
cnf = self.read_my_cnf_files(self.cnf_files, ['pager', 'skip-pager'])
if cnf['pager']:
special.set_pager(cnf['pager'])
if cnf['skip-pager']:
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.sqlexecute,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When mycli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
string = string.replace('\\u', sqlexecute.user or '(none)')
string = string.replace('\\h', sqlexecute.host or '(none)')
string = string.replace('\\d', sqlexecute.dbname or '(none)')
string = string.replace('\\t', sqlexecute.server_type()[0] or 'mycli')
string = string.replace('\\n', "\n")
return string
class PGCli(object):
def __init__(self,
force_passwd_prompt=False,
never_passwd_prompt=False,
pgexecute=None,
pgclirc_file=None):
self.force_passwd_prompt = force_passwd_prompt
self.never_passwd_prompt = never_passwd_prompt
self.pgexecute = pgexecute
from pgcli import __file__ as package_root
package_root = os.path.dirname(package_root)
default_config = os.path.join(package_root, 'pgclirc')
write_default_config(default_config, pgclirc_file)
self.pgspecial = PGSpecial()
# Load config.
c = self.config = load_config(pgclirc_file, default_config)
self.multi_line = c['main'].as_bool('multi_line')
self.vi_mode = c['main'].as_bool('vi')
self.pgspecial.timing_enabled = c['main'].as_bool('timing')
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
self.query_history = []
# Initialize completer
smart_completion = c['main'].as_bool('smart_completion')
completer = PGCompleter(smart_completion, pgspecial=self.pgspecial)
self.completer = completer
self._completer_lock = threading.Lock()
self.register_special_commands()
self.cli = None
def register_special_commands(self):
self.pgspecial.register(
self.change_db,
'\\c',
'\\c[onnect] database_name',
'Change to a new database.',
aliases=('use', '\\connect', 'USE'))
self.pgspecial.register(
self.refresh_completions,
'\\#',
'\\#',
'Refresh auto-completions.',
arg_type=NO_QUERY)
self.pgspecial.register(
self.refresh_completions,
'\\refresh',
'\\refresh',
'Refresh auto-completions.',
arg_type=NO_QUERY)
self.pgspecial.register(self.execute_from_file, '\\i', '\\i filename',
'Execute commands from file.')
def change_db(self, pattern, **_):
if pattern:
db = pattern[1:-1] if pattern[0] == pattern[-1] == '"' else pattern
self.pgexecute.connect(database=db)
else:
self.pgexecute.connect()
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.pgexecute.dbname, self.pgexecute.user))
def execute_from_file(self, pattern, **_):
if not pattern:
message = '\\i: missing required argument'
return [(None, None, None, message)]
try:
with open(os.path.expanduser(pattern), encoding='utf-8') as f:
query = f.read()
except IOError as e:
return [(None, None, None, str(e))]
return self.pgexecute.run(query, self.pgspecial)
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('pgcli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
root_logger.debug('Initializing pgcli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_dsn(self, dsn):
self.connect(dsn=dsn)
def connect_uri(self, uri):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.hostname, uri.username, uri.port,
uri.password)
def connect(self,
database='',
host='',
user='',
port='',
passwd='',
dsn=''):
# Connect to the database.
if not user:
user = getuser()
if not database:
database = user
# If password prompt is not forced but no password is provided, try
# getting it from environment variable.
if not self.force_passwd_prompt and not passwd:
passwd = os.environ.get('PGPASSWORD', '')
# Prompt for a password immediately if requested via the -W flag. This
# avoids wasting time trying to connect to the database and catching a
# no-password exception.
# If we successfully parsed a password from a URI, there's no need to
# prompt for it, even with the -W flag
if self.force_passwd_prompt and not passwd:
passwd = click.prompt(
'Password', hide_input=True, show_default=False, type=str)
# Prompt for a password after 1st attempt to connect without a password
# fails. Don't prompt if the -w flag is supplied
auto_passwd_prompt = not passwd and not self.never_passwd_prompt
# Attempt to connect to the database.
# Note that passwd may be empty on the first attempt. If connection
# fails because of a missing password, but we're allowed to prompt for
# a password (no -w flag), prompt for a passwd and try again.
try:
try:
pgexecute = PGExecute(database, user, passwd, host, port, dsn)
except OperationalError as e:
if ('no password supplied' in utf8tounicode(e.args[0])
and auto_passwd_prompt):
passwd = click.prompt(
'Password',
hide_input=True,
show_default=False,
type=str)
pgexecute = PGExecute(database, user, passwd, host, port,
dsn)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
click.secho(str(e), err=True, fg='red')
exit(1)
self.pgexecute = pgexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(
filename, sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(
sql, cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
pgexecute = self.pgexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
self.refresh_completions()
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = pgcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/pgcli')
print('Mail: https://groups.google.com/forum/#!forum/pgcli')
print('Home: http://pgcli.com')
def prompt_tokens(cli):
return [(Token.Prompt, '%s> ' % pgexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode,
lambda: self.completion_refresher.is_refreshing())
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=[
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = PGBuffer(
always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(os.path.expanduser(history_file)),
complete_while_typing=Always())
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
ignore_case=True)
self.cli = CommandLineInterface(
application=application, eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the pgexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the pgexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
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())
click.secho(str(e), err=True, fg='red')
continue
# 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', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in pgexecute.run(). Which causes
# finally clause to fail.
res = []
start = time()
# Run the query.
res = pgexecute.run(document.text, self.pgspecial)
duration = time() - start
successful = True
output = []
total = 0
for title, cur, headers, status in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and cur
and cur.rowcount > threshold):
click.secho(
'The result set has more than %s rows.' %
threshold,
fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
if self.pgspecial.auto_expand:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(
title, cur, headers, status, self.table_format,
self.pgspecial.expanded_output, max_width)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
pgexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except OperationalError as e:
reconnect = True
if ('server closed the connection' in utf8tounicode(
e.args[0])):
reconnect = click.prompt(
'Connection reset. Reconnect (Y/n)',
show_default=False,
type=bool,
default=True)
if reconnect:
try:
pgexecute.connect()
click.secho(
'Reconnected!\nTry the command again.',
fg='green')
except OperationalError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(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())
click.secho(str(e), err=True, fg='red')
else:
try:
click.echo_via_pager('\n'.join(output))
except KeyboardInterrupt:
pass
if self.pgspecial.timing_enabled:
print('Command Time: %0.03fs' % duration)
print('Format Time: %0.03fs' % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions()
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(pgexecute.search_path())
logger.debug('Search path: %r', self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def adjust_less_opts(self):
less_opts = os.environ.get('LESS', '')
self.logger.debug('Original value for LESS env var: %r', less_opts)
os.environ['LESS'] = '-SRXF'
return less_opts
def refresh_completions(self):
self.completion_refresher.refresh(self.pgexecute, self.pgspecial,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When pgcli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
class OCli(object):
default_prompt = '\\t \\u@\\h:\\d> '
max_len_prompt = 45
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = [
'~/login.conf',
]
system_config_files = []
default_config_file = os.path.join(PACKAGE_ROOT, 'okclirc')
def __init__(self,
sqlexecute=None,
prompt=None,
logfile=None,
defaults_suffix=None,
defaults_file=None,
login_path=None,
auto_vertical_output=False,
warn=None,
okclirc="~/.okclirc"):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
# self.cnf_files is a class variable that stores the list of oracle
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = ([self.default_config_file] + self.system_config_files +
[okclirc])
c = self.config = read_config_files(config_files)
self.multi_line = c['main'].as_bool('multi_line')
self.key_bindings = c['main']['key_bindings']
special.set_timing_enabled(c['main'].as_bool('timing'))
self.formatter = TabularOutputFormatter(
format_name=c['main']['table_format'])
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
c_ddl_warning = c['main'].as_bool('ddl_warning')
self.ddl_warning = c_ddl_warning if warn is None else warn
self.login_path_as_host = c['main'].as_bool('login_path_as_host')
# read from cli argument or user config file
self.auto_vertical_output = auto_vertical_output or \
c['main'].as_bool('auto_vertical_output')
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, okclirc)
# audit log
if self.logfile is None and 'audit_log' in c['main']:
try:
self.logfile = open(os.path.expanduser(c['main']['audit_log']),
'a')
except (IOError, OSError) as e:
self.echo(
'Error: Unable to open the audit log file. Your queries will not be logged.',
err=True,
fg='red')
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files,
['prompt'])['prompt']
self.prompt_format = prompt or prompt_cnf or c['main']['prompt'] or \
self.default_prompt
self.prompt_continuation_format = c['main']['prompt_continuation']
self.query_history = []
# Initialize completer.
self.smart_completion = c['main'].as_bool('smart_completion')
self.completer = SQLCompleter(
self.smart_completion,
supported_formats=self.formatter.supported_formats)
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_schema,
'use',
'use [schema]',
'Change to a new schema.',
aliases=['\\u'])
special.register_special_command(
self.change_db,
'connect',
'connect [database]',
'Reconnect to the database. Optional database argument.',
aliases=('\\r', ),
case_sensitive=True)
special.register_special_command(self.refresh_completions,
'refresh',
'refresh',
'Refresh auto-completions.',
arg_type=NO_QUERY,
aliases=('\\#', ))
special.register_special_command(
self.change_table_format,
'format',
'\\T [format]',
'Change the format used to output results (html, csv etc.).',
aliases=('\\T', ),
case_sensitive=True)
special.register_special_command(self.execute_from_file,
'@',
'a [filename]',
'Execute commands from file.',
aliases=['\\.', 'source'])
special.register_special_command(self.change_prompt_format,
'prompt',
'\\R',
'Change prompt format.',
aliases=('\\R', ),
case_sensitive=True)
def change_table_format(self, arg, **_):
try:
self.formatter.format_name = arg
yield (None, None, None, 'Changed table format to {}'.format(arg))
except ValueError:
msg = 'Table format {} not recognized. Allowed formats:'.format(
arg)
for table_type in self.formatter.supported_formats:
msg += "\n\t{}".format(table_type)
yield (None, None, None, msg)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user))
def change_schema(self, arg, **_):
if arg is None:
yield (None, None, None, 'Specify the schema to switch to.')
else:
schema_name = str(arg).upper()
self.sqlexecute.conn.current_schema = schema_name
self.sqlexecute.dbname = schema_name
yield (None, None, None, 'Schema updated to {}'.format(arg))
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.ddl_warning and confirm_ddl_query(query) is False):
message = 'Command execution stopped.'
return [(None, None, None, message)]
return self.sqlexecute.run(query)
def change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = 'Missing required argument, format.'
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
# Disable logging if value is NONE by switching to a no-op handler
# Set log level to a high value so it doesn't even waste cycles getting called.
if log_level.upper() == "NONE":
handler = NullHandler()
log_level = "CRITICAL"
else:
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('okcli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
logging.captureWarnings(True)
root_logger.debug('Initializing okcli logging.')
root_logger.debug('Log file %r.', log_file)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ['client']
if self.login_path and self.login_path != 'client':
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return {x: get(x) for x in keys}
def connect(self, database='', user='', passwd='', host=''):
cnf = {
'database': None,
'user': None,
'password': None,
'host': None,
}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf['database']
user = user or cnf['user'] or os.getenv('USER')
host = host or cnf['host'] or 'localhost'
passwd = cnf['password'] or passwd
if not passwd:
passwd = click.prompt('Password',
hide_input=True,
show_default=False,
type=str)
# Assume connecting to schema with same name as user by default
if not database:
database = user.upper()
# Connect to the database.
try:
from cx_Oracle import DatabaseError
try:
sqlexecute = SQLExecute(database, user, passwd, host)
except DatabaseError as e:
if ('invalid username/password' in str(e)):
passwd = click.prompt('Password',
hide_input=True,
show_default=False,
type=str)
sqlexecute = SQLExecute(database, user, passwd, host)
else:
raise
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed', exc_info=True)
self.echo(str(e), err=True, fg='red')
exit(1)
self.sqlexecute = sqlexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed by a ed. The reason for a
while loop is because a user might edit a query multiple times.
For eg:
r"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
# FIXME: using application.pre_run_callables like this here is not the best solution.
# It's internal api of prompt_toolkit that may change. This was added to fix
# https://github.com/dbcli/pgcli/issues/668. We may find a better way to do it in the future.
saved_callables = cli.application.pre_run_callables
while special.editor_command(document.text):
filename = special.get_filename(document.text)
query = (special.get_editor_query(document.text)
or self.get_last_query())
sql, message = special.open_external_editor(filename, sql=query)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql,
cursor_position=len(sql))
cli.application.pre_run_callables = []
document = cli.run()
continue
cli.application.pre_run_callables = saved_callables
return document
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
self.configure_pager()
if self.smart_completion:
self.refresh_completions()
key_binding_manager = okcli_bindings()
def prompt_tokens(cli):
prompt = self.get_prompt(self.prompt_format)
if self.prompt_format == self.default_prompt and len(
prompt) > self.max_len_prompt:
prompt = self.get_prompt('\\d> ')
return [(Token.Prompt, prompt)]
def get_continuation_tokens(cli, width):
continuation_prompt = self.get_prompt(
self.prompt_continuation_format)
return [(Token.Continuation, ' ' *
(width - len(continuation_prompt)) + continuation_prompt)]
def one_iteration(document=None):
if document is None:
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.ddl_warning:
destroy = confirm_ddl_query(document.text)
if destroy is None:
pass # Query was not destructive. Nothing to do here.
elif destroy is True:
self.echo('OK')
else:
self.echo('Cancelled')
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', document.text)
special.write_tee(
self.get_prompt(self.prompt_format) + document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.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 click.confirm('Do you want to continue?'):
self.echo("Aborted!", err=True, fg='red')
break
if self.auto_vertical_output:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = self.format_output(
title, cur, headers, special.is_expanded_output(),
max_width)
if cur is not None:
status = self.sqlexecute.get_status(cur)
t = time() - start
try:
if result_count > 0:
self.echo('')
try:
self.output('\n'.join(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:
# 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, document.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 Exception as e:
logger.debug("Error", exc_info=True)
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(document)
return # OK to just return, cuz the recursion call runs to the end.
except Exception as e:
logger.debug('Reconnect failed', exc_info=True)
self.echo(str(e), err=True, fg='red')
# If reconnection failed, don't proceed further.
return
else:
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):
self.refresh_completions(
reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.echo("Warning: This query was not logged.",
err=True,
fg='red')
query = Query(document.text, successful, mutating)
self.query_history.append(query)
get_toolbar_tokens = create_toolbar_tokens_func(
self.completion_refresher.is_refreshing)
layout = create_prompt_layout(
lexer=OracleLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
],
reserve_space_for_menu=self.get_reserved_space())
with self._completer_lock:
buf = CLIBuffer(always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(
os.path.expanduser(
os.environ.get('okcli_HISTFILE',
'~/.okcli-history'))),
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
if self.key_bindings == 'vi':
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
editing_mode=editing_mode,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
one_iteration()
except EOFError:
special.close_tee()
def log_output(self, output):
"""Log the output in the audit log, if it's enabled."""
if self.logfile:
self.logfile.write(utf8tounicode(output))
self.logfile.write('\n')
def echo(self, s, **kwargs):
"""Print a message to stdout.
The message will be logged in the audit log, if enabled.
All keyword arguments are passed to click.echo().
"""
self.log_output(s)
click.secho(s, **kwargs)
def output_fits_on_screen(self, output, status=None):
"""Check if the given output fits on the screen."""
size = self.cli.output.get_size()
margin = self.get_reserved_space() + self.get_prompt(
self.prompt_format).count('\n') + 1
if special.is_timing_enabled():
margin += 1
if status:
margin += 1 + status.count('\n')
for i, line in enumerate(output.splitlines(), 1):
if len(line) > size.columns or i > (size.rows - margin):
return False
return True
def output(self, output, status=None):
"""Output text to stdout or a pager command.
The status text is not outputted to pager or files.
The message will be logged in the audit log, if enabled. The
message will be written to the tee file, if enabled. The
message will be written to the output file, if enabled.
"""
if output:
self.log_output(output)
special.write_tee(output)
special.write_once(output)
if (self.explicit_pager
or (special.is_pager_enabled()
and not self.output_fits_on_screen(output, status))):
click.echo_via_pager(output)
else:
click.secho(output)
if status:
self.log_output(status)
click.secho(status)
def configure_pager(self):
# Provide sane defaults for less if they are empty.
if not os.environ.get('LESS'):
os.environ['LESS'] = '-RXF'
cnf = self.read_my_cnf_files(self.cnf_files, ['pager', 'skip-pager'])
if cnf['pager']:
special.set_pager(cnf['pager'])
self.explicit_pager = True
else:
self.explicit_pager = False
if cnf['skip-pager']:
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(
self.sqlexecute, self._on_completions_refreshed, {
'smart_completion': self.smart_completion,
'supported_formats': self.formatter.supported_formats
})
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When okcli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
host = self.login_path if self.login_path and self.login_path_as_host else sqlexecute.host
now = datetime.now()
string = string.replace('\\u', sqlexecute.user or '(none)')
string = string.replace('\\h', host or '(none)')
string = string.replace('\\d', sqlexecute.dbname or '(none)')
string = string.replace('\\t', sqlexecute.server_type()[0] or 'okcli')
string = string.replace('\\n', "\n")
string = string.replace('\\D', now.strftime('%a %b %d %H:%M:%S %Y'))
string = string.replace('\\m', now.strftime('%M'))
string = string.replace('\\P', now.strftime('%p'))
string = string.replace('\\R', now.strftime('%H'))
string = string.replace('\\r', now.strftime('%I'))
string = string.replace('\\s', now.strftime('%S'))
return string
def run_query(self, query, new_line=True):
"""Runs *query*."""
results = self.sqlexecute.run(query)
for result in results:
title, cur, headers, status = result
output = self.format_output(title, cur, headers)
for line in output:
click.echo(line, nl=new_line)
def format_output(self,
title,
cur,
headers,
expanded=False,
max_width=None):
expanded = expanded or self.formatter.format_name == 'vertical'
output = []
if title: # Only print the title if it's not None.
output.append(title)
if cur:
rows = list(cur)
formatted = self.formatter.format_output(
rows, headers, format_name='vertical' if expanded else None)
if (not expanded and max_width and rows
and content_exceeds_width(rows[0], max_width) and headers):
formatted = self.formatter.format_output(
rows, headers, format_name='vertical')
output.append(formatted)
return output
def get_reserved_space(self):
"""Get the number of lines to reserve for the completion menu."""
reserved_space_ratio = .45
max_reserved_space = 8
_, height = click.get_terminal_size()
return min(round(height * reserved_space_ratio), max_reserved_space)
def get_last_query(self):
"""Get the last query executed or None."""
return self.query_history[-1][0] if self.query_history else None
class VCli(object):
def __init__(self, vexecute=None, vclirc_file=None):
self.vexecute = vexecute
from vcli import __file__ as package_root
package_root = os.path.dirname(package_root)
default_config = os.path.join(package_root, 'vclirc')
write_default_config(default_config, vclirc_file)
self.vspecial = VSpecial()
# Load config.
c = self.config = load_config(vclirc_file, default_config)
self.multi_line = c['main'].as_bool('multi_line')
self.vi_mode = c['main'].as_bool('vi')
self.vspecial.timing_enabled = c['main'].as_bool('timing')
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
self.query_history = []
# Initialize completer
smart_completion = c['main'].as_bool('smart_completion')
completer = VCompleter(smart_completion, vspecial=self.vspecial)
self.completer = completer
self._completer_lock = threading.Lock()
self.register_special_commands()
self.cli = None
def register_special_commands(self):
self.vspecial.register(self.change_db,
'\\c',
'\\c[onnect] [DBNAME]',
'Connect to a new database',
aliases=('use', '\\connect', 'USE'))
self.vspecial.register(self.refresh_completions,
'\\#',
'\\#',
'Refresh auto-completions',
arg_type=NO_QUERY)
self.vspecial.register(self.refresh_completions,
'\\refresh',
'\\refresh',
'Refresh auto-completions',
arg_type=NO_QUERY)
def change_db(self, pattern, **_):
if pattern:
db = pattern[1:-1] if pattern[0] == pattern[-1] == '"' else pattern
self.vexecute.connect(database=db)
else:
self.vexecute.connect()
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.vexecute.dbname, self.vexecute.user), True)
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {
'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('vcli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
root_logger.debug('Initializing vcli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
host = uri.hostname or 'localhost'
user = uri.username or getpass.getuser()
port = uri.port or 5433
password = uri.password or ''
self.connect(database, host, user, port, password)
def connect(self, database, host, user, port, passwd):
# Connect to the database
try:
self.vexecute = VExecute(database, user, passwd, host, port)
except errors.DatabaseError as e: # Connection can fail
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
error_msg = str(e) or type(e).__name__
click.secho(error_msg, err=True, fg='red')
exit(1)
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql,
cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
vexecute = self.vexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
completer = self.completer
self.refresh_completions()
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = vcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
click.secho('Version: %s' % __version__)
def prompt_tokens(cli):
return [(Token.Prompt, '%s=> ' % vexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
input_processors = [
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
]
layout = create_prompt_layout(
lexer=PostgresLexer,
reserve_space_for_menu=8,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=input_processors)
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = VBuffer(always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(
os.path.expanduser(history_file)),
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the vexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the vexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
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())
click.secho(str(e), err=True, fg='red')
continue
# 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', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in vexecute.run(). Which causes
# finally clause to fail.
res = []
start = time()
# Run the query.
res = vexecute.run(document.text, self.vspecial)
file_output = None
stdout_output = []
for title, cur, headers, status, force_stdout 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):
click.secho(
'The result set has more than %s rows.' %
threshold,
fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
formatted = format_output(
title, cur, headers, status, self.table_format,
self.vspecial.expanded_output,
self.vspecial.aligned, self.vspecial.show_header)
if self.vspecial.output is not sys.stdout:
file_output = self.vspecial.output
if force_stdout or not file_output:
output = stdout_output
else:
output = file_output
write_output(output, formatted)
if hasattr(cur, 'rowcount'):
if self.vspecial.show_header:
if cur.rowcount == 1:
write_output(output, '(1 row)')
elif headers:
rowcount = max(cur.rowcount, 0)
write_output(output,
'(%d rows)' % rowcount)
if document.text.startswith(
'\\') and cur.rowcount == 0:
stdout_output = [
'No matching relations found.'
]
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
vexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except errors.ConnectionError as e:
reconnect = click.prompt(
'Connection reset. Reconnect (Y/n)',
show_default=False,
type=bool,
default=True)
if reconnect:
try:
vexecute.connect()
click.secho('Reconnected!\nTry the command again.',
fg='green')
except errors.DatabaseError as e:
click.secho(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())
click.secho(format_error(e), err=True, fg='red')
else:
successful = True
if stdout_output:
output = '\n'.join(stdout_output)
try:
click.echo_via_pager(output)
except KeyboardInterrupt:
pass
if file_output:
try:
file_output.flush()
except KeyboardInterrupt:
pass
if self.vspecial.timing_enabled:
print('Time: %0.03fs' % (time() - start))
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
need_completion_reset(document.text))
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(
vexecute.search_path())
logger.debug('Search path: %r',
self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def adjust_less_opts(self):
less_opts = os.environ.get('LESS', '')
self.logger.debug('Original value for LESS env var: %r', less_opts)
os.environ['LESS'] = '-RXF'
return less_opts
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.vexecute, self.vspecial,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.', True)]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When pgcli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
class MyCli(object):
default_prompt = "\\t \\u@\\h:\\d> "
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = ["/etc/my.cnf", "/etc/mysql/my.cnf", "/usr/local/etc/my.cnf", "~/.my.cnf"]
system_config_files = ["/etc/myclirc"]
default_config_file = os.path.join(PACKAGE_ROOT, "myclirc")
user_config_file = "~/.myclirc"
def __init__(
self,
sqlexecute=None,
prompt=None,
logfile=None,
defaults_suffix=None,
defaults_file=None,
login_path=None,
auto_vertical_output=False,
warn=None,
):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
self.auto_vertical_output = auto_vertical_output
# self.cnf_files is a class variable that stores the list of mysql
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = [self.default_config_file] + self.system_config_files + [self.user_config_file]
c = self.config = read_config_files(config_files)
self.multi_line = c["main"].as_bool("multi_line")
self.key_bindings = c["main"]["key_bindings"]
special.set_timing_enabled(c["main"].as_bool("timing"))
self.table_format = c["main"]["table_format"]
self.syntax_style = c["main"]["syntax_style"]
self.cli_style = c["colors"]
self.wider_completion_menu = c["main"].as_bool("wider_completion_menu")
c_dest_warning = c["main"].as_bool("destructive_warning")
self.destructive_warning = c_dest_warning if warn is None else warn
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, self.user_config_file)
# audit log
if self.logfile is None and "audit_log" in c["main"]:
try:
self.logfile = open(os.path.expanduser(c["main"]["audit_log"]), "a")
except (IOError, OSError) as e:
self.output(
"Error: Unable to open the audit log file. Your queries will not be logged.", err=True, fg="red"
)
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files, ["prompt"])["prompt"]
self.prompt_format = prompt or prompt_cnf or c["main"]["prompt"] or self.default_prompt
self.query_history = []
# Initialize completer.
smart_completion = c["main"].as_bool("smart_completion")
self.completer = SQLCompleter(smart_completion)
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
# Load .mylogin.cnf if it exists.
mylogin_cnf_path = get_mylogin_cnf_path()
if mylogin_cnf_path:
try:
mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path)
if mylogin_cnf_path and mylogin_cnf:
# .mylogin.cnf gets read last, even if defaults_file is specified.
self.cnf_files.append(mylogin_cnf)
elif mylogin_cnf_path and not mylogin_cnf:
# There was an error reading the login path file.
print("Error: Unable to read login path file.")
except CryptoError:
click.secho("Warning: .mylogin.cnf was not read: pycrypto " "module is not available.")
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_db, "use", "\\u", "Change to a new database.", aliases=("\\u",))
special.register_special_command(
self.change_db,
"connect",
"\\r",
"Reconnect to the database. Optional database argument.",
aliases=("\\r",),
case_sensitive=True,
)
special.register_special_command(
self.refresh_completions, "rehash", "\\#", "Refresh auto-completions.", arg_type=NO_QUERY, aliases=("\\#",)
)
special.register_special_command(
self.change_table_format, "tableformat", "\\T", "Change Table Type.", aliases=("\\T",), case_sensitive=True
)
special.register_special_command(
self.execute_from_file, "source", "\\. filename", "Execute commands from file.", aliases=("\\.",)
)
special.register_special_command(
self.change_prompt_format, "prompt", "\\R", "Change prompt format.", aliases=("\\R",), case_sensitive=True
)
def change_table_format(self, arg, **_):
if not arg in table_formats():
msg = "Table type %s not yet implemented. Allowed types:" % arg
for table_type in table_formats():
msg += "\n\t%s" % table_type
yield (None, None, None, msg)
else:
self.table_format = arg
yield (None, None, None, "Changed table Type to %s" % self.table_format)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (
None,
None,
None,
'You are now connected to database "%s" as ' 'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user),
)
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 change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = "Missing required argument, format."
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = self.config["main"]["log_file"]
log_level = self.config["main"]["log_level"]
level_map = {
"CRITICAL": logging.CRITICAL,
"ERROR": logging.ERROR,
"WARNING": logging.WARNING,
"INFO": logging.INFO,
"DEBUG": logging.DEBUG,
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
"%(asctime)s (%(process)d/%(threadName)s) " "%(name)s %(levelname)s - %(message)s"
)
handler.setFormatter(formatter)
root_logger = logging.getLogger("mycli")
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
# Only capture warnings on Python 2.7 and later.
try:
logging.captureWarnings(True)
except AttributeError:
pass
root_logger.debug("Initializing mycli logging.")
root_logger.debug("Log file %r.", log_file)
def connect_uri(self, uri, local_infile=None, ssl=None):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, uri.username, uri.password, uri.hostname, uri.port, local_infile=local_infile, ssl=ssl)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ["client"]
if self.login_path and self.login_path != "client":
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return dict([(x, get(x)) for x in keys])
def merge_ssl_with_cnf(self, ssl, cnf):
"""Merge SSL configuration dict with cnf dict"""
merged = {}
merged.update(ssl)
prefix = "ssl-"
for k, v in cnf.items():
# skip unrelated options
if not k.startswith(prefix):
continue
if v is None:
continue
# special case because PyMySQL argument is significantly different
# from commandline
if k == "ssl-verify-server-cert":
merged["check_hostname"] = v
else:
# use argument name just strip "ssl-" prefix
arg = k[len(prefix) :]
merged[arg] = v
return merged
def connect(
self, database="", user="", passwd="", host="", port="", socket="", charset="", local_infile="", ssl=""
):
cnf = {
"database": None,
"user": None,
"password": None,
"host": None,
"port": None,
"socket": None,
"default-character-set": None,
"local-infile": None,
"loose-local-infile": None,
"ssl-ca": None,
"ssl-cert": None,
"ssl-key": None,
"ssl-cipher": None,
"ssl-verify-serer-cert": None,
}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf["database"]
if port or host:
socket = ""
else:
socket = socket or cnf["socket"]
user = user or cnf["user"] or os.getenv("USER")
host = host or cnf["host"] or "localhost"
port = port or cnf["port"] or 3306
ssl = ssl or {}
try:
port = int(port)
except ValueError as e:
self.output("Error: Invalid port number: '{0}'.".format(port), err=True, fg="red")
exit(1)
passwd = passwd or cnf["password"]
charset = charset or cnf["default-character-set"] or "utf8"
# Favor whichever local_infile option is set.
for local_infile_option in (local_infile, cnf["local-infile"], cnf["loose-local-infile"], False):
try:
local_infile = str_to_bool(local_infile_option)
break
except (TypeError, ValueError):
pass
ssl = self.merge_ssl_with_cnf(ssl, cnf)
# prune lone check_hostname=False
if not any(v for v in ssl.values()):
ssl = None
# Connect to the database.
try:
try:
sqlexecute = SQLExecute(database, user, passwd, host, port, socket, charset, local_infile, ssl)
except OperationalError as e:
if "Access denied for user" in e.args[1]:
passwd = click.prompt("Password", hide_input=True, show_default=False, type=str)
sqlexecute = SQLExecute(database, user, passwd, host, port, socket, charset, local_infile, ssl)
else:
raise e
except Exception as e: # Connecting to a database could fail.
self.logger.debug("Database connection failed: %r.", e)
self.logger.error("traceback: %r", traceback.format_exc())
self.output(str(e), err=True, fg="red")
exit(1)
self.sqlexecute = sqlexecute
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename, sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql, cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
sqlexecute = self.sqlexecute
logger = self.logger
self.configure_pager()
self.refresh_completions()
project_root = os.path.dirname(PACKAGE_ROOT)
author_file = os.path.join(project_root, "AUTHORS")
sponsor_file = os.path.join(project_root, "SPONSORS")
key_binding_manager = mycli_bindings()
print("Version:", __version__)
print("Chat: https://gitter.im/dbcli/mycli")
print("Mail: https://groups.google.com/forum/#!forum/mycli-users")
print("Home: http://mycli.net")
print("Thanks to the contributor -", thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
def get_continuation_tokens(cli, width):
return [(Token.Continuation, " " * (width - 3) + "-> ")]
get_toolbar_tokens = create_toolbar_tokens_func(self.completion_refresher.is_refreshing)
layout = create_prompt_layout(
lexer=MyCliLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars="[](){}"),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone(),
)
],
)
with self._completer_lock:
buf = CLIBuffer(
always_multiline=self.multi_line,
completer=self.completer,
history=FileHistory(os.path.expanduser("~/.mycli-history")),
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT,
)
if self.key_bindings == "vi":
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
editing_mode=editing_mode,
ignore_case=True,
)
self.cli = CommandLineInterface(application=application, eventloop=create_eventloop())
try:
while True:
document = self.cli.run(reset_current_buffer=True)
special.set_expanded_output(False)
# The reason we check here instead of inside the sqlexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the
# sqlexecute.run() statement.
if quit_command(document.text):
raise EOFError
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.output(str(e), err=True, fg="red")
continue
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.output("Your call!")
else:
self.output("Wise choice!")
continue
# 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", document.text)
if self.logfile:
self.logfile.write("\n# %s\n" % datetime.now())
self.logfile.write(document.text)
self.logfile.write("\n")
successful = False
start = time()
res = sqlexecute.run(document.text)
successful = True
output = []
total = 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.output("The result set has more than %s rows." % threshold, fg="red")
if not click.confirm("Do you want to continue?"):
self.output("Aborted!", err=True, fg="red")
break
if self.auto_vertical_output:
max_width = self.cli.output.get_size().columns
else:
max_width = None
formatted = format_output(
title, cur, headers, status, self.table_format, special.is_expanded_output(), max_width
)
output.extend(formatted)
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except UnicodeDecodeError as e:
import pymysql
if pymysql.VERSION < (0, 6, 7):
message = (
"You are running an older version of pymysql.\n"
"Please upgrade to 0.6.7 or above to view binary data.\n"
"Try 'pip install -U pymysql'."
)
self.output(message)
else:
raise e
except KeyboardInterrupt:
# Restart connection to the database
sqlexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
self.output("cancelled query", err=True, fg="red")
except NotImplementedError:
self.output("Not Yet Implemented.", fg="yellow")
except OperationalError as e:
logger.debug("Exception: %r", e)
reconnect = True
if e.args[0] in (2003, 2006, 2013):
reconnect = click.prompt(
"Connection reset. Reconnect (Y/n)", show_default=False, type=bool, default=True
)
if reconnect:
logger.debug("Attempting to reconnect.")
try:
sqlexecute.connect()
logger.debug("Reconnected successfully.")
self.output("Reconnected!\nTry the command again.", fg="green")
except OperationalError as e:
logger.debug("Reconnect failed. e: %r", e)
self.output(str(e), err=True, fg="red")
continue # If reconnection failed, don't proceed further.
else: # If user chooses not to reconnect, don't proceed further.
continue
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
self.output(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.output(str(e), err=True, fg="red")
else:
try:
if special.is_pager_enabled():
self.output_via_pager("\n".join(output))
else:
self.output("\n".join(output))
except KeyboardInterrupt:
pass
if special.is_timing_enabled():
self.output("Time: %0.03fs" % total)
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.output("Warning: This query was not logged.", err=True, fg="red")
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
self.output("Goodbye!")
def output(self, text, **kwargs):
if self.logfile:
self.logfile.write(utf8tounicode(text))
self.logfile.write("\n")
click.secho(text, **kwargs)
def output_via_pager(self, text):
if self.logfile:
self.logfile.write(text)
self.logfile.write("\n")
click.echo_via_pager(text)
def configure_pager(self):
# Provide sane defaults for less.
os.environ["LESS"] = "-RXF"
cnf = self.read_my_cnf_files(self.cnf_files, ["pager", "skip-pager"])
if cnf["pager"]:
special.set_pager(cnf["pager"])
if cnf["skip-pager"]:
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.sqlexecute, self._on_completions_refreshed)
return [(None, None, None, "Auto-completion refresh started in the background.")]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When mycli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
string = string.replace("\\u", sqlexecute.user or "(none)")
string = string.replace("\\h", sqlexecute.host or "(none)")
string = string.replace("\\d", sqlexecute.dbname or "(none)")
string = string.replace("\\t", sqlexecute.server_type()[0] or "mycli")
string = string.replace("\\n", "\n")
return string
class PythonCommandLineInterface(object):
def __init__(
self,
get_globals=None,
get_locals=None,
stdin=None,
stdout=None,
vi_mode=False,
history_filename=None,
style=PythonStyle,
# For internal use.
_completer=None,
_validator=None,
_python_prompt_control=None,
_extra_buffers=None,
_extra_sidebars=None):
self.settings = PythonCLISettings()
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self.completer = _completer or PythonCompleter(self.get_globals,
self.get_locals)
self.validator = _validator or PythonValidator()
self.history = FileHistory(
history_filename) if history_filename else History()
self.python_prompt_control = _python_prompt_control or PythonPrompt(
self.settings)
self._extra_sidebars = _extra_sidebars or []
# Use a KeyBindingManager for loading the key bindings.
self.key_bindings_manager = KeyBindingManager(
enable_vi_mode=vi_mode, enable_system_prompt=True)
load_python_bindings(
self.key_bindings_manager,
self.settings,
add_buffer=self.add_new_python_buffer,
close_current_buffer=self.close_current_python_buffer)
self.get_signatures_thread_running = False
buffers = {
'default':
Buffer(focussable=AlwaysOff()
), # Never use or focus the default buffer.
'docstring':
Buffer(focussable=HasSignature(self.settings)
& ShowDocstring(self.settings)),
# XXX: also make docstring read only.
}
buffers.update(_extra_buffers or {})
self.cli = CommandLineInterface(
style=style,
key_bindings_registry=self.key_bindings_manager.registry,
buffers=buffers,
create_async_autocompleters=True)
def on_input_timeout():
"""
When there is no input activity,
in another thread, get the signature of the current code.
"""
if not self.cli.focus_stack.current.startswith('python-'):
return
# Never run multiple get-signature threads.
if self.get_signatures_thread_running:
return
self.get_signatures_thread_running = True
buffer = self.cli.current_buffer
document = buffer.document
def run():
script = get_jedi_script_from_document(document,
self.get_locals(),
self.get_globals())
# Show signatures in help text.
if script:
try:
signatures = script.call_signatures()
except ValueError:
# e.g. in case of an invalid \\x escape.
signatures = []
except Exception:
# Sometimes we still get an exception (TypeError), because
# of probably bugs in jedi. We can silence them.
# See: https://github.com/davidhalter/jedi/issues/492
signatures = []
else:
signatures = []
self.get_signatures_thread_running = False
# Set signatures and redraw if the text didn't change in the
# meantime. Otherwise request new signatures.
if buffer.text == document.text:
buffer.signatures = signatures
# Set docstring in docstring buffer.
if signatures:
string = signatures[0].docstring()
if not isinstance(string, six.text_type):
string = string.decode('utf-8')
self.cli.buffers['docstring'].reset(
initial_document=Document(string,
cursor_position=0))
else:
self.cli.buffers['docstring'].reset()
self.cli.request_redraw()
else:
on_input_timeout()
self.cli.run_in_executor(run)
self.cli.onInputTimeout += on_input_timeout
self.cli.onReset += self.key_bindings_manager.reset
self.add_new_python_buffer()
def _update_layout(self):
"""
Generate new layout.
(To be done when we add/remove buffers.)
"""
self.cli.layout = create_layout(self.cli.buffers,
self.settings,
self.key_bindings_manager,
self.python_prompt_control,
extra_sidebars=self._extra_sidebars)
def add_new_python_buffer(self):
# Create a new buffer.
buffer = self._create_buffer()
self.settings.buffer_index += 1
name = 'python-%i' % self.settings.buffer_index
# Insert and update layout.
self.cli.add_buffer(name, buffer, focus=True)
self._update_layout()
def close_current_python_buffer(self):
name, _ = current_python_buffer(self.cli, self.settings)
if name:
python_buffers_left = len(
[b for b in self.cli.buffers if b.startswith('python-')])
if python_buffers_left > 1:
focus_next_buffer(
self.cli,
name_filter=lambda name: name.startswith('python-'))
del self.cli.buffers[name]
self._update_layout()
else:
self.cli.set_exit()
def _create_buffer(self):
def is_buffer_multiline(document):
return (self.settings.paste_mode
or self.settings.currently_multiline
or document_is_multiline_python(document))
return PythonBuffer(is_multiline=is_buffer_multiline,
tempfile_suffix='.py',
history=self.history,
completer=self.completer,
validator=self.validator)
class VCli(object):
def __init__(self, vexecute=None, vclirc_file=None):
self.vexecute = vexecute
from vcli import __file__ as package_root
package_root = os.path.dirname(package_root)
default_config = os.path.join(package_root, 'vclirc')
write_default_config(default_config, vclirc_file)
self.vspecial = VSpecial()
# Load config.
c = self.config = load_config(vclirc_file, default_config)
self.multi_line = c['main'].as_bool('multi_line')
self.vi_mode = c['main'].as_bool('vi')
self.vspecial.timing_enabled = c['main'].as_bool('timing')
self.table_format = c['main']['table_format']
self.syntax_style = c['main']['syntax_style']
self.cli_style = c['colors']
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
self.query_history = []
# Initialize completer
smart_completion = c['main'].as_bool('smart_completion')
completer = VCompleter(smart_completion, vspecial=self.vspecial)
self.completer = completer
self._completer_lock = threading.Lock()
self.register_special_commands()
self.cli = None
def register_special_commands(self):
self.vspecial.register(self.change_db, '\\c',
'\\c[onnect] [DBNAME]',
'Connect to a new database',
aliases=('use', '\\connect', 'USE'))
self.vspecial.register(self.refresh_completions, '\\#', '\\#',
'Refresh auto-completions', arg_type=NO_QUERY)
self.vspecial.register(self.refresh_completions, '\\refresh',
'\\refresh', 'Refresh auto-completions',
arg_type=NO_QUERY)
def change_db(self, pattern, **_):
if pattern:
db = pattern[1:-1] if pattern[0] == pattern[-1] == '"' else pattern
self.vexecute.connect(database=db)
else:
self.vexecute.connect()
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.vexecute.dbname, self.vexecute.user), True)
def initialize_logging(self):
log_file = self.config['main']['log_file']
log_level = self.config['main']['log_level']
level_map = {'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
handler = logging.FileHandler(os.path.expanduser(log_file))
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('vcli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
root_logger.debug('Initializing vcli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
host = uri.hostname or 'localhost'
user = uri.username or getpass.getuser()
port = uri.port or 5433
password = uri.password or ''
self.connect(database, host, user, port, password)
def connect(self, database, host, user, port, passwd):
# Connect to the database
try:
self.vexecute = VExecute(database, user, passwd, host, port)
except errors.DatabaseError as e: # Connection can fail
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
error_msg = str(e) or type(e).__name__
click.secho(error_msg, err=True, fg='red')
exit(1)
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
while special.editor_command(document.text):
filename = special.get_filename(document.text)
sql, message = special.open_external_editor(filename,
sql=document.text)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(
sql, cursor_position=len(sql))
document = cli.run(False)
continue
return document
def run_cli(self):
vexecute = self.vexecute
logger = self.logger
original_less_opts = self.adjust_less_opts()
completer = self.completer
self.refresh_completions()
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = vcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
click.secho('Version: %s' % __version__)
def prompt_tokens(cli):
return [(Token.Prompt, '%s=> ' % vexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(lambda: self.vi_mode,
self.completion_refresher.is_refreshing)
input_processors = [
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
]
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=input_processors)
history_file = self.config['main']['history_file']
with self._completer_lock:
buf = VBuffer(always_multiline=self.multi_line, completer=self.completer,
history=FileHistory(os.path.expanduser(history_file)),
complete_while_typing=Always())
application = Application(style=style_factory(self.syntax_style, self.cli_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
document = self.cli.run()
# The reason we check here instead of inside the vexecute is
# because we want to raise the Exit exception which will be
# caught by the try/except block that wraps the vexecute.run()
# statement.
if quit_command(document.text):
raise EOFError
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())
click.secho(str(e), err=True, fg='red')
continue
# 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', document.text)
successful = False
# Initialized to [] because res might never get initialized
# if an exception occurs in vexecute.run(). Which causes
# finally clause to fail.
res = []
start = time()
# Run the query.
res = vexecute.run(document.text, self.vspecial)
duration = time() - start
file_output = None
stdout_output = []
total = 0
for title, cur, headers, status, force_stdout in res:
logger.debug("headers: %r", headers)
logger.debug("rows: %r", cur)
logger.debug("status: %r", status)
start = time()
threshold = 1000
if (is_select(status) and
cur and cur.rowcount > threshold):
click.secho('The result set has more than %s rows.'
% threshold, fg='red')
if not click.confirm('Do you want to continue?'):
click.secho("Aborted!", err=True, fg='red')
break
formatted = format_output(title, cur, headers, status,
self.table_format,
self.vspecial.expanded_output,
self.vspecial.aligned,
self.vspecial.show_header)
if self.vspecial.output is not sys.stdout:
file_output = self.vspecial.output
if force_stdout or not file_output:
output = stdout_output
else:
output = file_output
write_output(output, formatted)
if hasattr(cur, 'rowcount'):
if self.vspecial.show_header:
if cur.rowcount == 1:
write_output(output, '(1 row)')
elif headers:
write_output(output, '(%d rows)' % cur.rowcount)
if document.text.startswith('\\') and cur.rowcount == 0:
stdout_output = ['No matching relations found.']
end = time()
total += end - start
mutating = mutating or is_mutating(status)
except KeyboardInterrupt:
# Restart connection to the database
vexecute.connect()
logger.debug("cancelled query, sql: %r", document.text)
click.secho("cancelled query", err=True, fg='red')
except NotImplementedError:
click.secho('Not Yet Implemented.', fg="yellow")
except errors.ConnectionError as e:
reconnect = True
if ('Connection is closed' in utf8tounicode(e.args[0])):
reconnect = click.prompt('Connection reset. Reconnect (Y/n)',
show_default=False, type=bool, default=True)
if reconnect:
try:
vexecute.connect()
click.secho('Reconnected!\nTry the command again.', fg='green')
except errors.DatabaseError as e:
click.secho(str(e), err=True, fg='red')
else:
logger.error("sql: %r, error: %r", document.text, e)
logger.error("traceback: %r", traceback.format_exc())
click.secho(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())
click.secho(str(e), err=True, fg='red')
else:
successful = True
if stdout_output:
output = '\n'.join(stdout_output)
try:
click.echo_via_pager(output)
except KeyboardInterrupt:
pass
if file_output:
try:
file_output.flush()
except KeyboardInterrupt:
pass
if self.vspecial.timing_enabled:
print('Time: command: %0.03fs, total: %0.03fs' % (duration, total))
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(need_completion_reset(document.text))
# Refresh search_path to set default schema.
if need_search_path_refresh(document.text):
logger.debug('Refreshing search path')
with self._completer_lock:
self.completer.set_search_path(vexecute.search_path())
logger.debug('Search path: %r', self.completer.search_path)
query = Query(document.text, successful, mutating)
self.query_history.append(query)
except EOFError:
print ('Goodbye!')
finally: # Reset the less opts back to original.
logger.debug('Restoring env var LESS to %r.', original_less_opts)
os.environ['LESS'] = original_less_opts
def adjust_less_opts(self):
less_opts = os.environ.get('LESS', '')
self.logger.debug('Original value for LESS env var: %r', less_opts)
os.environ['LESS'] = '-RXF'
return less_opts
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(self.vexecute, self.vspecial,
self._on_completions_refreshed)
return [(None, None, None,
'Auto-completion refresh started in the background.', True)]
def _on_completions_refreshed(self, new_completer):
self._swap_completer_objects(new_completer)
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def _swap_completer_objects(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When pgcli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
class MyCli(object):
default_prompt = '\\t \\u@\\h:\\d> '
max_len_prompt = 45
defaults_suffix = None
# In order of being loaded. Files lower in list override earlier ones.
cnf_files = [
'/etc/my.cnf',
'/etc/mysql/my.cnf',
'/usr/local/etc/my.cnf',
'~/.my.cnf'
]
system_config_files = [
'/etc/myclirc',
]
default_config_file = os.path.join(PACKAGE_ROOT, 'myclirc')
def __init__(self, sqlexecute=None, prompt=None,
logfile=None, defaults_suffix=None, defaults_file=None,
login_path=None, auto_vertical_output=False, warn=None,
myclirc="~/.myclirc"):
self.sqlexecute = sqlexecute
self.logfile = logfile
self.defaults_suffix = defaults_suffix
self.login_path = login_path
# self.cnf_files is a class variable that stores the list of mysql
# config files to read in at launch.
# If defaults_file is specified then override the class variable with
# defaults_file.
if defaults_file:
self.cnf_files = [defaults_file]
# Load config.
config_files = ([self.default_config_file] + self.system_config_files +
[myclirc])
c = self.config = read_config_files(config_files)
self.multi_line = c['main'].as_bool('multi_line')
self.key_bindings = c['main']['key_bindings']
special.set_timing_enabled(c['main'].as_bool('timing'))
self.formatter = TabularOutputFormatter(
format_name=c['main']['table_format'])
sql_format.register_new_formatter(self.formatter)
self.formatter.mycli = self
self.syntax_style = c['main']['syntax_style']
self.less_chatty = c['main'].as_bool('less_chatty')
self.cli_style = c['colors']
self.output_style = style_factory(self.syntax_style, self.cli_style)
self.wider_completion_menu = c['main'].as_bool('wider_completion_menu')
c_dest_warning = c['main'].as_bool('destructive_warning')
self.destructive_warning = c_dest_warning if warn is None else warn
self.login_path_as_host = c['main'].as_bool('login_path_as_host')
# read from cli argument or user config file
self.auto_vertical_output = auto_vertical_output or \
c['main'].as_bool('auto_vertical_output')
# Write user config if system config wasn't the last config loaded.
if c.filename not in self.system_config_files:
write_default_config(self.default_config_file, myclirc)
# audit log
if self.logfile is None and 'audit_log' in c['main']:
try:
self.logfile = open(os.path.expanduser(c['main']['audit_log']), 'a')
except (IOError, OSError) as e:
self.echo('Error: Unable to open the audit log file. Your queries will not be logged.',
err=True, fg='red')
self.logfile = False
self.completion_refresher = CompletionRefresher()
self.logger = logging.getLogger(__name__)
self.initialize_logging()
prompt_cnf = self.read_my_cnf_files(self.cnf_files, ['prompt'])['prompt']
self.prompt_format = prompt or prompt_cnf or c['main']['prompt'] or \
self.default_prompt
self.prompt_continuation_format = c['main']['prompt_continuation']
keyword_casing = c['main'].get('keyword_casing', 'auto')
self.query_history = []
# Initialize completer.
self.smart_completion = c['main'].as_bool('smart_completion')
self.completer = SQLCompleter(
self.smart_completion,
supported_formats=self.formatter.supported_formats,
keyword_casing=keyword_casing)
self._completer_lock = threading.Lock()
# Register custom special commands.
self.register_special_commands()
# Load .mylogin.cnf if it exists.
mylogin_cnf_path = get_mylogin_cnf_path()
if mylogin_cnf_path:
mylogin_cnf = open_mylogin_cnf(mylogin_cnf_path)
if mylogin_cnf_path and mylogin_cnf:
# .mylogin.cnf gets read last, even if defaults_file is specified.
self.cnf_files.append(mylogin_cnf)
elif mylogin_cnf_path and not mylogin_cnf:
# There was an error reading the login path file.
print('Error: Unable to read login path file.')
self.cli = None
def register_special_commands(self):
special.register_special_command(self.change_db, 'use',
'\\u', 'Change to a new database.', aliases=('\\u',))
special.register_special_command(self.change_db, 'connect',
'\\r', 'Reconnect to the database. Optional database argument.',
aliases=('\\r', ), case_sensitive=True)
special.register_special_command(self.refresh_completions, 'rehash',
'\\#', 'Refresh auto-completions.', arg_type=NO_QUERY, aliases=('\\#',))
special.register_special_command(
self.change_table_format, 'tableformat', '\\T',
'Change the table format used to output results.',
aliases=('\\T',), case_sensitive=True)
special.register_special_command(self.execute_from_file, 'source', '\\. filename',
'Execute commands from file.', aliases=('\\.',))
special.register_special_command(self.change_prompt_format, 'prompt',
'\\R', 'Change prompt format.', aliases=('\\R',), case_sensitive=True)
def change_table_format(self, arg, **_):
try:
self.formatter.format_name = arg
yield (None, None, None,
'Changed table format to {}'.format(arg))
except ValueError:
msg = 'Table format {} not recognized. Allowed formats:'.format(
arg)
for table_type in self.formatter.supported_formats:
msg += "\n\t{}".format(table_type)
yield (None, None, None, msg)
def change_db(self, arg, **_):
if arg is None:
self.sqlexecute.connect()
else:
self.sqlexecute.connect(database=arg)
yield (None, None, None, 'You are now connected to database "%s" as '
'user "%s"' % (self.sqlexecute.dbname, self.sqlexecute.user))
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 change_prompt_format(self, arg, **_):
"""
Change the prompt format.
"""
if not arg:
message = 'Missing required argument, format.'
return [(None, None, None, message)]
self.prompt_format = self.get_prompt(arg)
return [(None, None, None, "Changed prompt format to %s" % arg)]
def initialize_logging(self):
log_file = os.path.expanduser(self.config['main']['log_file'])
log_level = self.config['main']['log_level']
level_map = {'CRITICAL': logging.CRITICAL,
'ERROR': logging.ERROR,
'WARNING': logging.WARNING,
'INFO': logging.INFO,
'DEBUG': logging.DEBUG
}
# Disable logging if value is NONE by switching to a no-op handler
# Set log level to a high value so it doesn't even waste cycles getting called.
if log_level.upper() == "NONE":
handler = logging.NullHandler()
log_level = "CRITICAL"
elif dir_path_exists(log_file):
handler = logging.FileHandler(log_file)
else:
self.echo(
'Error: Unable to open the log file "{}".'.format(log_file),
err=True, fg='red')
return
formatter = logging.Formatter(
'%(asctime)s (%(process)d/%(threadName)s) '
'%(name)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root_logger = logging.getLogger('mycli')
root_logger.addHandler(handler)
root_logger.setLevel(level_map[log_level.upper()])
logging.captureWarnings(True)
root_logger.debug('Initializing mycli logging.')
root_logger.debug('Log file %r.', log_file)
def connect_uri(self, uri, local_infile=None, ssl=None):
uri = urlparse(uri)
database = uri.path[1:] # ignore the leading fwd slash
self.connect(database, unquote(uri.username), unquote(uri.password),
uri.hostname, uri.port, local_infile=local_infile, ssl=ssl)
def read_my_cnf_files(self, files, keys):
"""
Reads a list of config files and merges them. The last one will win.
:param files: list of files to read
:param keys: list of keys to retrieve
:returns: tuple, with None for missing keys.
"""
cnf = read_config_files(files)
sections = ['client']
if self.login_path and self.login_path != 'client':
sections.append(self.login_path)
if self.defaults_suffix:
sections.extend([sect + self.defaults_suffix for sect in sections])
def get(key):
result = None
for sect in cnf:
if sect in sections and key in cnf[sect]:
result = cnf[sect][key]
return result
return {x: get(x) for x in keys}
def merge_ssl_with_cnf(self, ssl, cnf):
"""Merge SSL configuration dict with cnf dict"""
merged = {}
merged.update(ssl)
prefix = 'ssl-'
for k, v in cnf.items():
# skip unrelated options
if not k.startswith(prefix):
continue
if v is None:
continue
# special case because PyMySQL argument is significantly different
# from commandline
if k == 'ssl-verify-server-cert':
merged['check_hostname'] = v
else:
# use argument name just strip "ssl-" prefix
arg = k[len(prefix):]
merged[arg] = v
return merged
def connect(self, database='', user='', passwd='', host='', port='',
socket='', charset='', local_infile='', ssl=''):
cnf = {'database': None,
'user': None,
'password': None,
'host': None,
'port': None,
'socket': None,
'default-character-set': None,
'local-infile': None,
'loose-local-infile': None,
'ssl-ca': None,
'ssl-cert': None,
'ssl-key': None,
'ssl-cipher': None,
'ssl-verify-serer-cert': None,
}
cnf = self.read_my_cnf_files(self.cnf_files, cnf.keys())
# Fall back to config values only if user did not specify a value.
database = database or cnf['database']
if port or host:
socket = ''
else:
socket = socket or cnf['socket']
user = user or cnf['user'] or os.getenv('USER')
host = host or cnf['host']
port = port or cnf['port']
ssl = ssl or {}
passwd = passwd or cnf['password']
charset = charset or cnf['default-character-set'] or 'utf8'
# Favor whichever local_infile option is set.
for local_infile_option in (local_infile, cnf['local-infile'],
cnf['loose-local-infile'], False):
try:
local_infile = str_to_bool(local_infile_option)
break
except (TypeError, ValueError):
pass
ssl = self.merge_ssl_with_cnf(ssl, cnf)
# prune lone check_hostname=False
if not any(v for v in ssl.values()):
ssl = None
# Connect to the database.
def _connect():
try:
self.sqlexecute = SQLExecute(database, user, passwd, host, port,
socket, charset, local_infile, ssl)
except OperationalError as e:
if ('Access denied for user' in e.args[1]):
new_passwd = click.prompt('Password', hide_input=True,
show_default=False, type=str, err=True)
self.sqlexecute = SQLExecute(database, user, new_passwd, host, port,
socket, charset, local_infile, ssl)
else:
raise e
try:
if (socket is host is port is None) and not WIN:
# Try a sensible default socket first (simplifies auth)
# If we get a connection error, try tcp/ip localhost
try:
socket = '/var/run/mysqld/mysqld.sock'
_connect()
except OperationalError as e:
# These are "Can't open socket" and 2x "Can't connect"
if [code for code in (2001, 2002, 2003) if code == e.args[0]]:
self.logger.debug('Database connection failed: %r.', e)
self.logger.error(
"traceback: %r", traceback.format_exc())
self.logger.debug('Retrying over TCP/IP')
self.echo(str(e), err=True)
self.echo(
'Failed to connect by socket, retrying over TCP/IP', err=True)
# Else fall back to TCP/IP localhost
socket = ""
host = 'localhost'
port = 3306
_connect()
else:
raise e
else:
host = host or 'localhost'
port = port or 3306
# Bad ports give particularly daft error messages
try:
port = int(port)
except ValueError as e:
self.echo("Error: Invalid port number: '{0}'.".format(port),
err=True, fg='red')
exit(1)
_connect()
except Exception as e: # Connecting to a database could fail.
self.logger.debug('Database connection failed: %r.', e)
self.logger.error("traceback: %r", traceback.format_exc())
self.echo(str(e), err=True, fg='red')
exit(1)
def handle_editor_command(self, cli, document):
"""
Editor command is any query that is prefixed or suffixed
by a '\e'. The reason for a while loop is because a user
might edit a query multiple times.
For eg:
"select * from \e"<enter> to edit it in vim, then come
back to the prompt with the edited query "select * from
blah where q = 'abc'\e" to edit it again.
:param cli: CommandLineInterface
:param document: Document
:return: Document
"""
# FIXME: using application.pre_run_callables like this here is not the best solution.
# It's internal api of prompt_toolkit that may change. This was added to fix
# https://github.com/dbcli/pgcli/issues/668. We may find a better way to do it in the future.
saved_callables = cli.application.pre_run_callables
while special.editor_command(document.text):
filename = special.get_filename(document.text)
query = (special.get_editor_query(document.text) or
self.get_last_query())
sql, message = special.open_external_editor(filename, sql=query)
if message:
# Something went wrong. Raise an exception and bail.
raise RuntimeError(message)
cli.current_buffer.document = Document(sql, cursor_position=len(sql))
cli.application.pre_run_callables = []
document = cli.run()
continue
cli.application.pre_run_callables = saved_callables
return document
def run_cli(self):
iterations = 0
sqlexecute = self.sqlexecute
logger = self.logger
self.configure_pager()
if self.smart_completion:
self.refresh_completions()
author_file = os.path.join(PACKAGE_ROOT, 'AUTHORS')
sponsor_file = os.path.join(PACKAGE_ROOT, 'SPONSORS')
history_file = os.path.expanduser(
os.environ.get('MYCLI_HISTFILE', '~/.mycli-history'))
if dir_path_exists(history_file):
history = FileHistory(history_file)
else:
history = None
self.echo(
'Error: Unable to open the history file "{}". '
'Your query history will not be saved.'.format(history_file),
err=True, fg='red')
key_binding_manager = mycli_bindings()
if not self.less_chatty:
print('Version:', __version__)
print('Chat: https://gitter.im/dbcli/mycli')
print('Mail: https://groups.google.com/forum/#!forum/mycli-users')
print('Home: http://mycli.net')
print('Thanks to the contributor -', thanks_picker([author_file, sponsor_file]))
def prompt_tokens(cli):
prompt = self.get_prompt(self.prompt_format)
if self.prompt_format == self.default_prompt and len(prompt) > self.max_len_prompt:
prompt = self.get_prompt('\\d> ')
return [(Token.Prompt, prompt)]
def get_continuation_tokens(cli, width):
continuation_prompt = self.get_prompt(self.prompt_continuation_format)
return [(Token.Continuation, ' ' * (width - len(continuation_prompt)) + continuation_prompt)]
def show_suggestion_tip():
return iterations < 2
def one_iteration(document=None):
if document is None:
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
# 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', document.text)
special.write_tee(self.get_prompt(self.prompt_format) + document.text)
if self.logfile:
self.logfile.write('\n# %s\n' % datetime.now())
self.logfile.write(document.text)
self.logfile.write('\n')
successful = False
start = time()
res = sqlexecute.run(document.text)
self.formatter.query = document.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.cli.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
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:
# 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, document.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(document)
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", 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:
if is_dropping_database(document.text, self.sqlexecute.dbname):
self.sqlexecute.dbname = None
self.sqlexecute.connect()
# Refresh the table names and column names if necessary.
if need_completion_refresh(document.text):
self.refresh_completions(
reset=need_completion_reset(document.text))
finally:
if self.logfile is False:
self.echo("Warning: This query was not logged.",
err=True, fg='red')
query = Query(document.text, successful, mutating)
self.query_history.append(query)
get_toolbar_tokens = create_toolbar_tokens_func(
self.completion_refresher.is_refreshing,
show_suggestion_tip)
layout = create_prompt_layout(
lexer=MyCliLexer,
multiline=True,
get_prompt_tokens=prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
extra_input_processors=[ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()
)],
reserve_space_for_menu=self.get_reserved_space()
)
with self._completer_lock:
buf = CLIBuffer(
always_multiline=self.multi_line, completer=self.completer,
history=history, auto_suggest=AutoSuggestFromHistory(),
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
if self.key_bindings == 'vi':
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
application = Application(
style=style_from_pygments(style_cls=self.output_style),
layout=layout, buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY, editing_mode=editing_mode,
ignore_case=True)
self.cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
try:
while True:
one_iteration()
iterations += 1
except EOFError:
special.close_tee()
if not self.less_chatty:
self.echo('Goodbye!')
def log_output(self, output):
"""Log the output in the audit log, if it's enabled."""
if self.logfile:
click.echo(utf8tounicode(output), file=self.logfile)
def echo(self, s, **kwargs):
"""Print a message to stdout.
The message will be logged in the audit log, if enabled.
All keyword arguments are passed to click.echo().
"""
self.log_output(s)
click.secho(s, **kwargs)
def get_output_margin(self, status=None):
"""Get the output margin (number of rows for the prompt, footer and
timing message."""
margin = self.get_reserved_space() + self.get_prompt(self.prompt_format).count('\n') + 1
if special.is_timing_enabled():
margin += 1
if status:
margin += 1 + status.count('\n')
return margin
def output(self, output, status=None):
"""Output text to stdout or a pager command.
The status text is not outputted to pager or files.
The message will be logged in the audit log, if enabled. The
message will be written to the tee file, if enabled. The
message will be written to the output file, if enabled.
"""
if output:
size = self.cli.output.get_size()
margin = self.get_output_margin(status)
fits = True
buf = []
output_via_pager = self.explicit_pager and special.is_pager_enabled()
for i, line in enumerate(output, 1):
self.log_output(line)
special.write_tee(line)
special.write_once(line)
if fits or output_via_pager:
# buffering
buf.append(line)
if len(line) > size.columns or i > (size.rows - margin):
fits = False
if not self.explicit_pager and special.is_pager_enabled():
# doesn't fit, use pager
output_via_pager = True
if not output_via_pager:
# doesn't fit, flush buffer
for line in buf:
click.secho(line)
buf = []
else:
click.secho(line)
if buf:
if output_via_pager:
# sadly click.echo_via_pager doesn't accept generators
click.echo_via_pager("\n".join(buf))
else:
for line in buf:
click.secho(line)
if status:
self.log_output(status)
click.secho(status)
def configure_pager(self):
# Provide sane defaults for less if they are empty.
if not os.environ.get('LESS'):
os.environ['LESS'] = '-RXF'
cnf = self.read_my_cnf_files(self.cnf_files, ['pager', 'skip-pager'])
if cnf['pager']:
special.set_pager(cnf['pager'])
self.explicit_pager = True
else:
self.explicit_pager = False
if cnf['skip-pager'] or not self.config['main'].as_bool('enable_pager'):
special.disable_pager()
def refresh_completions(self, reset=False):
if reset:
with self._completer_lock:
self.completer.reset_completions()
self.completion_refresher.refresh(
self.sqlexecute, self._on_completions_refreshed,
{'smart_completion': self.smart_completion,
'supported_formats': self.formatter.supported_formats,
'keyword_casing': self.completer.keyword_casing})
return [(None, None, None,
'Auto-completion refresh started in the background.')]
def _on_completions_refreshed(self, new_completer):
"""Swap the completer object in cli with the newly created completer.
"""
with self._completer_lock:
self.completer = new_completer
# When mycli is first launched we call refresh_completions before
# instantiating the cli object. So it is necessary to check if cli
# exists before trying the replace the completer object in cli.
if self.cli:
self.cli.current_buffer.completer = new_completer
if self.cli:
# After refreshing, redraw the CLI to clear the statusbar
# "Refreshing completions..." indicator
self.cli.request_redraw()
def get_completions(self, text, cursor_positition):
with self._completer_lock:
return self.completer.get_completions(
Document(text=text, cursor_position=cursor_positition), None)
def get_prompt(self, string):
sqlexecute = self.sqlexecute
host = self.login_path if self.login_path and self.login_path_as_host else sqlexecute.host
now = datetime.now()
string = string.replace('\\u', sqlexecute.user or '(none)')
string = string.replace('\\h', host or '(none)')
string = string.replace('\\d', sqlexecute.dbname or '(none)')
string = string.replace('\\t', sqlexecute.server_type()[0] or 'mycli')
string = string.replace('\\n', "\n")
string = string.replace('\\D', now.strftime('%a %b %d %H:%M:%S %Y'))
string = string.replace('\\m', now.strftime('%M'))
string = string.replace('\\P', now.strftime('%p'))
string = string.replace('\\R', now.strftime('%H'))
string = string.replace('\\r', now.strftime('%I'))
string = string.replace('\\s', now.strftime('%S'))
string = string.replace('\\p', str(sqlexecute.port))
string = string.replace('\\_', ' ')
return string
def run_query(self, query, new_line=True):
"""Runs *query*."""
results = self.sqlexecute.run(query)
for result in results:
title, cur, headers, status = result
self.formatter.query = query
output = self.format_output(title, cur, headers)
for line in output:
click.echo(line, nl=new_line)
def format_output(self, title, cur, headers, expanded=False,
max_width=None):
expanded = expanded or self.formatter.format_name == 'vertical'
output = []
output_kwargs = {
'disable_numparse': True,
'preserve_whitespace': True,
'preprocessors': (preprocessors.align_decimals, ),
'style': self.output_style
}
if title: # Only print the title if it's not None.
output = itertools.chain(output, [title])
if cur:
column_types = None
if hasattr(cur, 'description'):
def get_col_type(col):
col_type = FIELD_TYPES.get(col[1], text_type)
return col_type if type(col_type) is type else text_type
column_types = [get_col_type(col) for col in cur.description]
if max_width is not None:
cur = list(cur)
formatted = self.formatter.format_output(
cur, headers, format_name='vertical' if expanded else None,
column_types=column_types,
**output_kwargs)
if isinstance(formatted, (text_type)):
formatted = formatted.splitlines()
formatted = iter(formatted)
first_line = next(formatted)
formatted = itertools.chain([first_line], formatted)
if (not expanded and max_width and headers and cur and
len(first_line) > max_width):
formatted = self.formatter.format_output(
cur, headers, format_name='vertical', column_types=column_types, **output_kwargs)
if isinstance(formatted, (text_type)):
formatted = iter(formatted.splitlines())
output = itertools.chain(output, formatted)
return output
def get_reserved_space(self):
"""Get the number of lines to reserve for the completion menu."""
reserved_space_ratio = .45
max_reserved_space = 8
_, height = click.get_terminal_size()
return min(int(round(height * reserved_space_ratio)), max_reserved_space)
def get_last_query(self):
"""Get the last query executed or None."""
return self.query_history[-1][0] if self.query_history else None
class PythonCommandLineInterface(object):
def __init__(self,
eventloop,
get_globals=None, get_locals=None,
stdin=None, stdout=None,
vi_mode=False, history_filename=None,
style=PythonStyle,
# For internal use.
_completer=None,
_validator=None,
_lexer=None,
_python_prompt_control=None,
_extra_buffers=None,
_extra_buffer_processors=None,
_extra_sidebars=None):
self.settings = PythonCLISettings()
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self.completer = _completer or PythonCompleter(self.get_globals, self.get_locals)
self.validator = _validator or PythonValidator()
self.history = FileHistory(history_filename) if history_filename else History()
self.python_prompt_control = _python_prompt_control or PythonPrompt(self.settings)
self._extra_sidebars = _extra_sidebars or []
self._extra_buffer_processors = _extra_buffer_processors or []
self._lexer = _lexer or PythonLexer
# Use a KeyBindingManager for loading the key bindings.
self.key_bindings_manager = KeyBindingManager(enable_vi_mode=vi_mode,
enable_open_in_editor=True,
enable_system_prompt=True)
load_python_bindings(self.key_bindings_manager, self.settings)
self.get_signatures_thread_running = False
buffers = {
'default': self._create_python_buffer(),
'docstring': Buffer(), # XXX: make docstring read only.
}
buffers.update(_extra_buffers or {})
self.cli = CommandLineInterface(
eventloop=eventloop,
style=style,
key_bindings_registry=self.key_bindings_manager.registry,
buffers=buffers,
paste_mode=Condition(lambda cli: self.settings.paste_mode),
layout=self._create_layout(),
on_abort=AbortAction.RETRY,
on_exit=AbortAction.RAISE_EXCEPTION)
def on_input_timeout():
"""
When there is no input activity,
in another thread, get the signature of the current code.
"""
if self.cli.focus_stack.current != 'default':
return
# Never run multiple get-signature threads.
if self.get_signatures_thread_running:
return
self.get_signatures_thread_running = True
buffer = self.cli.current_buffer
document = buffer.document
def run():
script = get_jedi_script_from_document(document, self.get_locals(), self.get_globals())
# Show signatures in help text.
if script:
try:
signatures = script.call_signatures()
except ValueError:
# e.g. in case of an invalid \\x escape.
signatures = []
except Exception:
# Sometimes we still get an exception (TypeError), because
# of probably bugs in jedi. We can silence them.
# See: https://github.com/davidhalter/jedi/issues/492
signatures = []
else:
signatures = []
self.get_signatures_thread_running = False
# Set signatures and redraw if the text didn't change in the
# meantime. Otherwise request new signatures.
if buffer.text == document.text:
self.settings.signatures = signatures
# Set docstring in docstring buffer.
if signatures:
string = signatures[0].docstring()
if not isinstance(string, six.text_type):
string = string.decode('utf-8')
self.cli.buffers['docstring'].reset(
initial_document=Document(string, cursor_position=0))
else:
self.cli.buffers['docstring'].reset()
self.cli.request_redraw()
else:
on_input_timeout()
self.cli.eventloop.run_in_executor(run)
def reset():
self.key_bindings_manager.reset()
self.settings.signatures = []
self.cli.onReset += reset
self.cli.onInputTimeout += on_input_timeout
def _create_layout(self):
"""
Generate new layout.
"""
return create_layout(
self.settings, self.key_bindings_manager, self.python_prompt_control,
lexer=self._lexer,
extra_buffer_processors=self._extra_buffer_processors,
extra_sidebars=self._extra_sidebars)
def _create_python_buffer(self):
def is_buffer_multiline():
return (self.settings.paste_mode or
document_is_multiline_python(b.document))
b = Buffer(
is_multiline=Condition(is_buffer_multiline),
complete_while_typing=Condition(lambda: self.settings.complete_while_typing),
enable_history_search=Always(),
tempfile_suffix='.py',
history=self.history,
completer=self.completer,
validator=self.validator)
return b
class PythonCommandLineInterface(object):
def __init__(self,
get_globals=None, get_locals=None,
stdin=None, stdout=None,
vi_mode=False, history_filename=None,
style=PythonStyle,
# For internal use.
_completer=None,
_validator=None,
_lexer=None,
_python_prompt_control=None,
_extra_buffers=None,
_extra_buffer_processors=None,
_extra_sidebars=None):
self.settings = PythonCLISettings()
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self.completer = _completer or PythonCompleter(self.get_globals, self.get_locals)
self.validator = _validator or PythonValidator()
self.history = FileHistory(history_filename) if history_filename else History()
self.python_prompt_control = _python_prompt_control or PythonPrompt(self.settings)
self._extra_sidebars = _extra_sidebars or []
self._extra_buffer_processors = _extra_buffer_processors or []
self._lexer = _lexer or PythonLexer
# Use a KeyBindingManager for loading the key bindings.
self.key_bindings_manager = KeyBindingManager(enable_vi_mode=vi_mode,
enable_open_in_editor=True,
enable_system_prompt=True)
load_python_bindings(self.key_bindings_manager, self.settings,
add_buffer=self.add_new_python_buffer,
close_current_buffer=self.close_current_python_buffer)
self.get_signatures_thread_running = False
buffers = {
'default': Buffer(focussable=Never()), # Never use or focus the default buffer.
'docstring': Buffer(focussable=HasSignature(self.settings) & ShowDocstring(self.settings)),
# XXX: also make docstring read only.
}
buffers.update(_extra_buffers or {})
self.cli = CommandLineInterface(
style=style,
key_bindings_registry=self.key_bindings_manager.registry,
buffers=buffers,
complete_while_typing=Always(),
on_abort=AbortAction.RETRY,
on_exit=AbortAction.RAISE_EXCEPTION)
def on_input_timeout():
"""
When there is no input activity,
in another thread, get the signature of the current code.
"""
if not self.cli.focus_stack.current.startswith('python-'):
return
# Never run multiple get-signature threads.
if self.get_signatures_thread_running:
return
self.get_signatures_thread_running = True
buffer = self.cli.current_buffer
document = buffer.document
def run():
script = get_jedi_script_from_document(document, self.get_locals(), self.get_globals())
# Show signatures in help text.
if script:
try:
signatures = script.call_signatures()
except ValueError:
# e.g. in case of an invalid \\x escape.
signatures = []
except Exception:
# Sometimes we still get an exception (TypeError), because
# of probably bugs in jedi. We can silence them.
# See: https://github.com/davidhalter/jedi/issues/492
signatures = []
else:
signatures = []
self.get_signatures_thread_running = False
# Set signatures and redraw if the text didn't change in the
# meantime. Otherwise request new signatures.
if buffer.text == document.text:
buffer.signatures = signatures
# Set docstring in docstring buffer.
if signatures:
string = signatures[0].docstring()
if not isinstance(string, six.text_type):
string = string.decode('utf-8')
self.cli.buffers['docstring'].reset(
initial_document=Document(string, cursor_position=0))
else:
self.cli.buffers['docstring'].reset()
self.cli.request_redraw()
else:
on_input_timeout()
self.cli.eventloop.run_in_executor(run)
self.cli.onInputTimeout += on_input_timeout
self.cli.onReset += self.key_bindings_manager.reset
self.add_new_python_buffer()
def _update_layout(self):
"""
Generate new layout.
(To be done when we add/remove buffers.)
"""
self.cli.layout = create_layout(
self.cli.buffers, self.settings, self.key_bindings_manager, self.python_prompt_control,
lexer=self._lexer,
extra_buffer_processors=self._extra_buffer_processors,
extra_sidebars=self._extra_sidebars)
def add_new_python_buffer(self):
# Create a new buffer.
buffer = self._create_buffer()
self.settings.buffer_index += 1
name = 'python-%i' % self.settings.buffer_index
# Insert and update layout.
self.cli.add_buffer(name, buffer, focus=True)
self._update_layout()
def close_current_python_buffer(self):
name, _ = current_python_buffer(self.cli, self.settings)
if name:
python_buffers_left = len([b for b in self.cli.buffers if b.startswith('python-')])
if python_buffers_left > 1:
focus_next_buffer(self.cli, name_filter=lambda name: name.startswith('python-'))
del self.cli.buffers[name]
self._update_layout()
else:
self.cli.set_exit()
def _create_buffer(self):
def is_buffer_multiline(document):
return (self.settings.paste_mode or
self.settings.currently_multiline or
document_is_multiline_python(document))
return PythonBuffer(
is_multiline=is_buffer_multiline,
tempfile_suffix='.py',
history=self.history,
completer=self.completer,
validator=self.validator)
