Imported Upstream version 2.99.6upstream/2.99.6

40 files changed, 2445 insertions, 0 deletions

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommand.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommand.cpp
new file mode 100644
index 0000000..3002ee5
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommand.cpp
@@ -0,0 +1,334 @@
+#include "clicommand.h"
+#include "qio.h"
+#include "cli_config.h"
+#include "cliutils.h"
+#include "common/utils.h"
+#include "common/utils_sql.h"
+#include "clicommandfactory.h"
+#include "services/dbmanager.h"
+#include "schemaresolver.h"
+#include "cli.h"
+
+#include <QDir>
+
+CliCommand::CliCommand()
+{
+}
+
+CliCommand::~CliCommand()
+{
+}
+
+void CliCommand::setup(CLI *cli)
+{
+    this->cli = cli;
+    defineSyntax();
+}
+
+bool CliCommand::isAsyncExecution() const
+{
+    return false;
+}
+
+bool CliCommand::parseArgs(const QStringList& args)
+{
+    bool res = syntax.parse(args);
+
+    if (!res && !syntax.getErrorText().isEmpty())
+    {
+        println(syntax.getErrorText());
+        println();
+    }
+
+    return res;
+}
+
+QString CliCommand::usage() const
+{
+    return syntax.getSyntaxDefinition();
+}
+
+QString CliCommand::usage(const QString& alias) const
+{
+    return syntax.getSyntaxDefinition(alias);
+}
+
+QString CliCommand::getName() const
+{
+    return syntax.getName();
+}
+
+QStringList CliCommand::complete(const QStringList& args)
+{
+    syntax.parse(args.mid(0, args.size() - 1));
+
+    QStringList results;
+    results += syntax.getStrictArgumentCandidates();
+    foreach (int id, syntax.getRegularArgumentCandidates())
+        results += getCompletionValuesFor(id, args.last());
+
+    return results;
+}
+
+QStringList CliCommand::aliases() const
+{
+    return syntax.getAliases();
+}
+
+void CliCommand::println(const QString &str)
+{
+    qOut << str << "\n";
+    qOut.flush();
+}
+
+void CliCommand::print(const QString& str)
+{
+    qOut << str;
+    qOut.flush();
+}
+
+void CliCommand::printBox(const QString& str)
+{
+    int cols = getCliColumns();
+
+    QStringList lines = str.split("\n");
+    println(".---------------------------");
+    foreach (const QString& line, lines)
+    {
+        foreach (const QString& lineWithMargin, applyMargin(line, cols - 3)) // 2 for "| " and 1 for final new line character
+            println("| " + lineWithMargin);
+    }
+
+    println("`---------------------------");
+}
+
+void CliCommand::printUsage()
+{
+    println(tr("Usage: %1%2").arg(CFG_CLI.Console.CommandPrefixChar.get()).arg(usage()));
+    println("");
+}
+
+QString CliCommand::getFilterAndFixDir(QDir& dir, const QString& path)
+{
+    if (path.isEmpty())
+        return "*";
+
+    QString filter;
+    QDir tempDir;
+    tempDir.setPath(path);
+    if (tempDir.exists() && path.endsWith("/"))
+    {
+        dir.cd(path);
+        filter = "*";
+    }
+    else if (tempDir.cdUp())
+    {
+        dir.setPath(path);
+        dir.cdUp();
+        filter = QFileInfo(path).fileName() + "*";
+    }
+    else
+    {
+        filter = path;
+    }
+    return filter;
+}
+
+QStringList CliCommand::getCompletionDbNames()
+{
+    QStringList results = DBLIST->getDbNames();
+    results.sort(Qt::CaseInsensitive);
+    return results;
+}
+
+QStringList CliCommand::getCompletionTables()
+{
+    QStringList results;
+    if (!cli->getCurrentDb())
+        return results;
+
+    Dialect dialect = Dialect::Sqlite3;
+
+    SchemaResolver resolver(cli->getCurrentDb());
+    resolver.setIgnoreSystemObjects(true);
+    results += wrapObjNamesIfNeeded(resolver.getTables(), dialect);
+    results += prefixEach("temp.", wrapObjNamesIfNeeded(resolver.getTables("temp"), dialect));
+    foreach (const QString& database, resolver.getDatabases())
+        results += prefixEach(wrapObjIfNeeded(database, Dialect::Sqlite3)+".", wrapObjNamesIfNeeded(resolver.getTables(database), dialect));
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionIndexes()
+{
+    QStringList results;
+    if (!cli->getCurrentDb())
+        return results;
+
+    Dialect dialect = Dialect::Sqlite3;
+
+    SchemaResolver resolver(cli->getCurrentDb());
+    resolver.setIgnoreSystemObjects(true);
+    results += wrapObjNamesIfNeeded(resolver.getIndexes(), dialect);
+    results += prefixEach("temp.", wrapObjNamesIfNeeded(resolver.getIndexes("temp"), dialect));
+    foreach (const QString& database, resolver.getDatabases())
+        results += prefixEach(wrapObjIfNeeded(database, Dialect::Sqlite3)+".", wrapObjNamesIfNeeded(resolver.getIndexes(database), dialect));
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionTriggers()
+{
+    QStringList results;
+    if (!cli->getCurrentDb())
+        return results;
+
+    Dialect dialect = Dialect::Sqlite3;
+
+    SchemaResolver resolver(cli->getCurrentDb());
+    resolver.setIgnoreSystemObjects(true);
+    results += wrapObjNamesIfNeeded(resolver.getTriggers(), dialect);
+    results += prefixEach("temp.", wrapObjNamesIfNeeded(resolver.getTriggers("temp"), dialect));
+    foreach (const QString& database, resolver.getDatabases())
+        results += prefixEach(wrapObjIfNeeded(database, Dialect::Sqlite3)+".", wrapObjNamesIfNeeded(resolver.getTriggers(database), dialect));
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionViews()
+{
+    QStringList results;
+    if (!cli->getCurrentDb())
+        return results;
+
+    Dialect dialect = Dialect::Sqlite3;
+
+    SchemaResolver resolver(cli->getCurrentDb());
+    resolver.setIgnoreSystemObjects(true);
+    results += wrapObjNamesIfNeeded(resolver.getViews(), dialect);
+    results += prefixEach("temp.", wrapObjNamesIfNeeded(resolver.getViews("temp"), dialect));
+    foreach (const QString& database, resolver.getDatabases())
+        results += prefixEach(wrapObjIfNeeded(database, Dialect::Sqlite3)+".", wrapObjNamesIfNeeded(resolver.getViews(database), dialect));
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionDbNamesOrFiles(const QString& partialValue)
+{
+    QStringList results = getCompletionDbNames();
+    results += getCompletionFiles(partialValue);
+    return results;
+}
+
+QStringList CliCommand::getCompletionFiles(const QString& partialValue)
+{
+    QDir dir;
+    QString filter = getFilterAndFixDir(dir, partialValue);
+    QFileInfoList entries = dir.entryInfoList({filter}, QDir::Files, QDir::LocaleAware|QDir::Name);
+
+    QStringList results;
+    QString name;
+    foreach (const QFileInfo& entry, entries)
+    {
+        name = entry.fileName();
+        if (dir != QDir::current())
+            name.prepend(dir.path() + "/");
+
+        results << name;
+    }
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionDirs(const QString& partialValue)
+{
+    QDir dir;
+    QString filter = getFilterAndFixDir(dir, partialValue);
+    QFileInfoList entries = dir.entryInfoList({filter}, QDir::Dirs|QDir::NoDotAndDotDot, QDir::LocaleAware|QDir::Name);
+
+    QStringList results;
+    QString name;
+    foreach (const QFileInfo& entry, entries)
+    {
+        name = entry.fileName();
+        if (dir != QDir::current())
+            name.prepend(dir.path() + "/");
+
+        results << name;
+    }
+
+    return results;
+}
+
+QStringList CliCommand::getCompletionDirsOrFiles(const QString& partialValue)
+{
+    QStringList results = getCompletionDirs(partialValue);
+    results += getCompletionFiles(partialValue);
+    return results;
+}
+
+QStringList CliCommand::getCompletionInternalDbs()
+{
+    QStringList results;
+    if (!cli->getCurrentDb())
+        return results;
+
+    SchemaResolver resolver(cli->getCurrentDb());
+    results += resolver.getDatabases().toList();
+    results << "main" << "temp";
+    results.sort(Qt::CaseInsensitive);
+    return results;
+}
+
+QStringList CliCommand::getCompletionValuesFor(int id, const QString& partialValue)
+{
+    QStringList results;
+    if (id < 1000) // this base implementation is only for local enum values (>= 1000).
+        return results;
+
+    switch (static_cast<ArgIds>(id))
+    {
+        case CliCommand::DB_NAME:
+            results += getCompletionDbNames();
+            break;
+        case CliCommand::DB_NAME_OR_FILE:
+            results += getCompletionDbNamesOrFiles(partialValue);
+            break;
+        case CliCommand::FILE_PATH:
+            results += getCompletionFiles(partialValue);
+            break;
+        case CliCommand::DIR_PATH:
+            results += getCompletionDirs(partialValue);
+            break;
+        case CliCommand::CMD_NAME:
+            results += CliCommandFactory::getCommandNames();
+            break;
+        case CliCommand::DIR_OR_FILE:
+            results += getCompletionDirsOrFiles(partialValue);
+            break;
+        case CliCommand::INTRNAL_DB:
+            results += getCompletionInternalDbs();
+            break;
+        case CliCommand::TABLE:
+            results += getCompletionTables();
+            break;
+        case CliCommand::INDEX:
+            results += getCompletionIndexes();
+            break;
+        case CliCommand::TRIGGER:
+            results += getCompletionTriggers();
+            break;
+        case CliCommand::VIEW:
+            results += getCompletionViews();
+            break;
+        case CliCommand::STRING:
+            break;
+    }
+
+    return results;
+}
+
+QString CliCommand::cmdName(const QString& cmd)
+{
+    return CFG_CLI.Console.CommandPrefixChar.get()+cmd;
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommand.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommand.h
new file mode 100644
index 0000000..4fc8618
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommand.h
@@ -0,0 +1,97 @@
+#ifndef CLICOMMAND_H
+#define CLICOMMAND_H
+
+#include "clicommandsyntax.h"
+#include <QStringList>
+#include <QTextStream>
+#include <QObject>
+#include <QDir>
+
+class QFile;
+class SQLiteStudio;
+class DbManager;
+class CLI;
+class Config;
+
+class CliCommand : public QObject
+{
+    Q_OBJECT
+
+    public:
+        CliCommand();
+        virtual ~CliCommand();
+
+        void setup(CLI* cli);
+
+        /**
+         * @brief execute
+         */
+        virtual void execute() = 0;
+
+        /**
+         * @brief Short help displayed in commands index.
+         * @return Single line of command description.
+         */
+        virtual QString shortHelp() const = 0;
+
+        /**
+         * @brief Full help is displayed when help for specific command was requested.
+         * @return Multi line, detailed description, including syntax.
+         */
+        virtual QString fullHelp() const = 0;
+
+        virtual bool isAsyncExecution() const;
+
+        virtual void defineSyntax() = 0;
+
+        QStringList aliases() const;
+        bool parseArgs(const QStringList& args);
+        QString usage() const;
+        QString usage(const QString& alias) const;
+        QString getName() const;
+        QStringList complete(const QStringList& args);
+
+    protected:
+        enum ArgIds
+        {
+            DB_NAME         = 1000,
+            DB_NAME_OR_FILE = 1001,
+            FILE_PATH       = 1002,
+            DIR_OR_FILE     = 1003,
+            DIR_PATH        = 1004,
+            CMD_NAME        = 1005,
+            INTRNAL_DB      = 1006,
+            STRING          = 1007,
+            TABLE           = 1008,
+            INDEX           = 1009,
+            TRIGGER         = 1010,
+            VIEW            = 1011
+        };
+
+        static void println(const QString& str = "");
+        static void print(const QString& str = "");
+        static void printBox(const QString& str);
+        static QString cmdName(const QString& cmd);
+
+        void printUsage();
+        QString getFilterAndFixDir(QDir& dir, const QString& path);
+        QStringList getCompletionDbNames();
+        QStringList getCompletionTables();
+        QStringList getCompletionIndexes();
+        QStringList getCompletionTriggers();
+        QStringList getCompletionViews();
+        QStringList getCompletionDbNamesOrFiles(const QString& partialValue);
+        QStringList getCompletionFiles(const QString& partialValue);
+        QStringList getCompletionDirs(const QString& partialValue);
+        QStringList getCompletionDirsOrFiles(const QString& partialValue);
+        QStringList getCompletionInternalDbs();
+        virtual QStringList getCompletionValuesFor(int id, const QString& partialValue);
+
+        CLI* cli = nullptr;
+        CliCommandSyntax syntax;
+
+    signals:
+        void execComplete();
+};
+
+#endif // CLICOMMAND_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.cpp
new file mode 100644
index 0000000..e3c14bb
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.cpp
@@ -0,0 +1,36 @@
+#include "clicommandadd.h"
+#include "cli.h"
+#include "services/dbmanager.h"
+
+void CliCommandAdd::execute()
+{
+    if (!DBLIST->addDb(syntax.getArgument(DB_NAME), syntax.getArgument(FILE_PATH)))
+    {
+        println(tr("Could not add database %1 to list.").arg(syntax.getArgument(FILE_PATH)));
+        return;
+    }
+
+    cli->setCurrentDb(DBLIST->getByName(syntax.getArgument(DB_NAME)));
+    println(tr("Database added: %1").arg(cli->getCurrentDb()->getName()));
+}
+
+QString CliCommandAdd::shortHelp() const
+{
+    return tr("adds new database to the list");
+}
+
+QString CliCommandAdd::fullHelp() const
+{
+    return tr(
+                "Adds given database pointed by <path> with given <name> to list the databases list. "
+                "The <name> is just a symbolic name that you can later refer to. Just pick any unique name. "
+                "For list of databases already on the list use %1 command."
+             ).arg(cmdName("dblist"));
+}
+
+void CliCommandAdd::defineSyntax()
+{
+    syntax.setName("add");
+    syntax.addArgument(DB_NAME, tr("name", "CLI command syntax"));
+    syntax.addArgument(FILE_PATH, tr("path", "CLI command syntax"));
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.h
new file mode 100644
index 0000000..ae09ee1
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandadd.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDADD_H
+#define CLICOMMANDADD_H
+
+#include "clicommand.h"
+
+class CliCommandAdd : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDADD_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.cpp
new file mode 100644
index 0000000..0ca6cb6
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.cpp
@@ -0,0 +1,34 @@
+#include "clicommandcd.h"

+#include <QCoreApplication>

+#include <QDir>

+

+void CliCommandCd::execute()

+{

+    QDir dir;

+    dir.cd(syntax.getArgument(DIR_PATH));

+    if (QDir::setCurrent(dir.absolutePath()))

+        println(tr("Changed directory to: %1").arg(QDir::currentPath()));

+    else

+        println(tr("Could not change directory to: %1").arg(QDir::currentPath()));

+}

+

+QString CliCommandCd::shortHelp() const

+{

+    return tr("changes current workind directory");

+}

+

+QString CliCommandCd::fullHelp() const

+{

+    return tr(

+                "Very similar command to 'cd' known from Unix systems and Windows. "

+                "It requires a <path> argument to be passed, therefore calling %1 will always cause a change of the directory. "

+                "To learn what's the current working directory use %2 command and to list contents of the current working directory "

+                "use %3 command."

+             );

+}

+

+void CliCommandCd::defineSyntax()

+{

+    syntax.setName("cd");

+    syntax.addArgument(DIR_PATH, tr("path", "CLI command syntax"));

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.h
new file mode 100644
index 0000000..4cfabc9
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandcd.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDCD_H

+#define CLICOMMANDCD_H

+

+#include "clicommand.h"

+

+class CliCommandCd : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+};

+

+#endif // CLICOMMANDCD_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.cpp
new file mode 100644
index 0000000..44fc72c
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.cpp
@@ -0,0 +1,51 @@
+#include "clicommandclose.h"
+#include "cli.h"
+#include "db/db.h"
+#include "services/dbmanager.h"
+
+void CliCommandClose::execute()
+{
+    if (!syntax.isArgumentSet(DB_NAME) && !cli->getCurrentDb())
+    {
+        println(tr("Cannot call %1 when no database is set to be current. Specify current database with %2 command or pass database name to %3.")
+                .arg(cmdName("close")).arg(cmdName("use")).arg(cmdName("close")));
+        return;
+    }
+
+    if (syntax.isArgumentSet(DB_NAME))
+    {
+        Db* db = DBLIST->getByName(syntax.getArgument(DB_NAME));
+        if (db)
+        {
+            db->close();
+            println(tr("Connection to database %1 closed.").arg(db->getName()));
+        }
+        else
+            println(tr("No such database: %1. Use %2 to see list of known databases.").arg(syntax.getArgument(DB_NAME)).arg(cmdName("dblist")));
+    }
+    else if (cli->getCurrentDb())
+    {
+        cli->getCurrentDb()->close();
+        println(tr("Connection to database %1 closed.").arg(cli->getCurrentDb()->getName()));
+    }
+}
+
+QString CliCommandClose::shortHelp() const
+{
+    return tr("closes given (or current) database");
+}
+
+QString CliCommandClose::fullHelp() const
+{
+    return tr(
+                "Closes database connection. If the database was already closed, nothing happens. "
+                "If <name> is provided, it should be name of the database to close (as printed by %1 command). "
+                "The the <name> is not provided, then current working database is closed (see help for %2 for details)."
+                ).arg(cmdName("dblist")).arg(cmdName("use"));
+}
+
+void CliCommandClose::defineSyntax()
+{
+    syntax.setName("close");
+    syntax.addArgument(DB_NAME, tr("name", "CLI command syntax"), false);
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.h
new file mode 100644
index 0000000..04fbbeb
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandclose.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDCLOSE_H
+#define CLICOMMANDCLOSE_H
+
+#include "clicommand.h"
+
+class CliCommandClose : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDCLOSE_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.cpp
new file mode 100644
index 0000000..cbc16b6
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.cpp
@@ -0,0 +1,86 @@
+#include "clicommanddblist.h"
+#include "cli.h"
+#include "services/dbmanager.h"
+#include "common/unused.h"
+#include "common/utils.h"
+#include <QList>
+
+void CliCommandDbList::execute()
+{
+    if (!cli->getCurrentDb())
+    {
+        println(tr("No current working database defined."));
+        return;
+    }
+
+    QString currentName = cli->getCurrentDb()->getName();
+
+    println(tr("Databases:"));
+    QList<Db*> dbList = DBLIST->getDbList();
+    QString path;
+    QString msg;
+
+    int maxNameLength = tr("Name", "CLI db name column").length();
+    int lgt = 0;
+    foreach (Db* db, dbList)
+    {
+        lgt = db->getName().length() + 1;
+        maxNameLength = qMax(maxNameLength, lgt);
+    }
+
+    int connStateLength = qMax(tr("Open", "CLI connection state column").length(), tr("Closed", "CLI connection state column").length());
+    connStateLength = qMax(connStateLength, tr("Connection", "CLI connection state column").length());
+
+    msg = pad(tr("Name", "CLI db name column"), maxNameLength, ' ');
+    msg += "|";
+    msg += pad(tr("Connection", "CLI connection state column"), connStateLength, ' ');
+    msg += "|";
+    msg += tr("Database file path");
+    println(msg);
+
+    msg = QString("-").repeated(maxNameLength);
+    msg += "+";
+    msg += QString("-").repeated(connStateLength);
+    msg += "+";
+    msg += QString("-").repeated(tr("Database file path").length() + 1);
+    println(msg);
+
+    QString name;
+    foreach (Db* db, dbList)
+    {
+        bool open = db->isOpen();
+        path = db->getPath();
+        name = db->getName();
+        if (name == currentName)
+            name.prepend("*");
+        else
+            name.prepend(" ");
+
+        msg = pad(name, maxNameLength, ' ');
+        msg += "|";
+        msg += pad((open ? tr("Open") : tr("Closed")), connStateLength, ' ');
+        msg += "|";
+        msg += path;
+        println(msg);
+    }
+}
+
+QString CliCommandDbList::shortHelp() const
+{
+    return tr("prints list of registered databases");
+}
+
+QString CliCommandDbList::fullHelp() const
+{
+    return tr(
+                "Prints list of databases registered in the SQLiteStudio. Each database on the list can be in open or closed state "
+                "and .dblist tells you that. The current working database (aka default database) is also marked on the list with '*' at the start of its name. "
+                "See help for %1 command to learn about the default database."
+                ).arg(cmdName("use"));
+}
+
+void CliCommandDbList::defineSyntax()
+{
+    syntax.setName("dblist");
+    syntax.addAlias("databases");
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.h
new file mode 100644
index 0000000..ecbaa6f
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddblist.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDDBLIST_H
+#define CLICOMMANDDBLIST_H
+
+#include "clicommand.h"
+
+class CliCommandDbList : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDDBLIST_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.cpp
new file mode 100644
index 0000000..4865e23
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.cpp
@@ -0,0 +1,26 @@
+#include "clicommanddesc.h"

+

+CliCommandDesc::CliCommandDesc()

+{

+}

+

+void CliCommandDesc::execute()

+{

+

+}

+

+QString CliCommandDesc::shortHelp() const

+{

+    return tr("shows details about the table");

+}

+

+QString CliCommandDesc::fullHelp() const

+{

+    return QString();

+}

+

+void CliCommandDesc::defineSyntax()

+{

+    syntax.setName("desc");

+    syntax.addArgument(TABLE, tr("table"));

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.h
new file mode 100644
index 0000000..ee52c30
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddesc.h
@@ -0,0 +1,16 @@
+#ifndef CLICOMMANDDESC_H

+#define CLICOMMANDDESC_H

+

+#include "clicommand.h"

+

+class CliCommandDesc : public CliCommand

+{

+    public:

+        CliCommandDesc();

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+};

+

+#endif // CLICOMMANDDESC_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.cpp
new file mode 100644
index 0000000..c61f503
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.cpp
@@ -0,0 +1,50 @@
+#include "clicommanddir.h"

+#include <QDir>

+

+void CliCommandDir::execute()

+{

+    QDir dir;

+    QFileInfoList entries;

+

+    if (syntax.isArgumentSet(DIR_OR_FILE))

+    {

+        QString filter = getFilterAndFixDir(dir, syntax.getArgument(DIR_OR_FILE));

+        entries = dir.entryInfoList({filter}, QDir::AllEntries|QDir::NoDotAndDotDot, QDir::DirsFirst|QDir::LocaleAware|QDir::Name);

+    }

+    else

+        entries = dir.entryInfoList(QDir::AllEntries|QDir::NoDotAndDotDot, QDir::DirsFirst|QDir::LocaleAware|QDir::Name);

+

+    QString name;

+    foreach (const QFileInfo& entry, entries)

+    {

+        name = entry.fileName();

+        if (entry.isDir())

+            name += "/";

+

+        if (dir != QDir::current())

+            name.prepend(dir.path()+"/");

+

+        println(name);

+    }

+}

+

+QString CliCommandDir::shortHelp() const

+{

+    return tr("lists directories and files in current working directory");

+}

+

+QString CliCommandDir::fullHelp() const

+{

+    return tr(

+                "This is very similar to 'dir' command known from Windows and 'ls' command from Unix systems.\n"

+                "\n"

+                "You can pass <pattern> with wildcard characters to filter output."

+             );

+}

+

+void CliCommandDir::defineSyntax()

+{

+    syntax.setName("dir");

+    syntax.addAlias("ls");

+    syntax.addArgument(DIR_OR_FILE, tr("pattern"), false);

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.h
new file mode 100644
index 0000000..8aa5ccc
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanddir.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDDIR_H

+#define CLICOMMANDDIR_H

+

+#include "clicommand.h"

+

+class CliCommandDir : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+};

+

+#endif // CLICOMMANDDIR_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.cpp
new file mode 100644
index 0000000..2c45e1d
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.cpp
@@ -0,0 +1,26 @@
+#include "clicommandexit.h"
+#include "cli.h"
+#include "common/unused.h"
+
+void CliCommandExit::execute()
+{
+    cli->exit();
+}
+
+QString CliCommandExit::shortHelp() const
+{
+    return tr("quits the application");
+}
+
+QString CliCommandExit::fullHelp() const
+{
+    return tr(
+                "Quits the application. Settings are stored in configuration file and will be restored on next startup."
+             );
+}
+
+void CliCommandExit::defineSyntax()
+{
+    syntax.setName("exit");
+    syntax.addAlias("quit");
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.h
new file mode 100644
index 0000000..dc061bb
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandexit.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDEXIT_H
+#define CLICOMMANDEXIT_H
+
+#include "clicommand.h"
+
+class CliCommandExit : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDEXIT_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.cpp
new file mode 100644
index 0000000..742709b
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.cpp
@@ -0,0 +1,85 @@
+#include "clicommandfactory.h"
+#include "cli.h"
+#include "clicommandadd.h"
+#include "clicommandremove.h"
+#include "clicommandexit.h"
+#include "clicommanddblist.h"
+#include "clicommanduse.h"
+#include "clicommandopen.h"
+#include "clicommandclose.h"
+#include "clicommandsql.h"
+#include "clicommandhelp.h"
+#include "clicommandtables.h"
+#include "clicommandmode.h"
+#include "clicommandnullvalue.h"
+#include "clicommandhistory.h"
+#include "clicommanddir.h"
+#include "clicommandpwd.h"
+#include "clicommandcd.h"
+#include "clicommandtree.h"
+#include "clicommanddesc.h"
+#include <QDebug>
+
+QHash<QString,CliCommandFactory::CliCommandCreatorFunc> CliCommandFactory::mapping;
+
+#define REGISTER_CMD(Cmd) registerCommand([]() -> CliCommand* {return new Cmd();})
+
+void CliCommandFactory::init()
+{
+    REGISTER_CMD(CliCommandAdd);
+    REGISTER_CMD(CliCommandRemove);
+    REGISTER_CMD(CliCommandExit);
+    REGISTER_CMD(CliCommandDbList);
+    REGISTER_CMD(CliCommandUse);
+    REGISTER_CMD(CliCommandOpen);
+    REGISTER_CMD(CliCommandClose);
+    REGISTER_CMD(CliCommandSql);
+    REGISTER_CMD(CliCommandHelp);
+    REGISTER_CMD(CliCommandTables);
+    REGISTER_CMD(CliCommandMode);
+    REGISTER_CMD(CliCommandNullValue);
+    REGISTER_CMD(CliCommandHistory);
+    REGISTER_CMD(CliCommandDir);
+    REGISTER_CMD(CliCommandPwd);
+    REGISTER_CMD(CliCommandCd);
+    REGISTER_CMD(CliCommandTree);
+    REGISTER_CMD(CliCommandDesc);
+}
+
+CliCommand *CliCommandFactory::getCommand(const QString &cmdName)
+{
+    if (!mapping.contains(cmdName))
+        return nullptr;
+
+    return mapping[cmdName]();
+}
+
+QHash<QString,CliCommand*> CliCommandFactory::getAllCommands()
+{
+    QHash<QString,CliCommand*> results;
+    QHashIterator<QString,CliCommandFactory::CliCommandCreatorFunc> it(mapping);
+    while (it.hasNext())
+    {
+        it.next();
+        results[it.key()] = it.value()();
+    }
+
+    return results;
+}
+
+QStringList CliCommandFactory::getCommandNames()
+{
+    return mapping.keys();
+}
+
+void CliCommandFactory::registerCommand(CliCommandCreatorFunc func)
+{
+    CliCommand* cmd = func();
+    cmd->defineSyntax();
+
+    mapping[cmd->getName()] = func;
+    foreach (const QString& alias, cmd->aliases())
+        mapping[alias] = func;
+
+    delete cmd;
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.h
new file mode 100644
index 0000000..4329463
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandfactory.h
@@ -0,0 +1,25 @@
+#ifndef CLICOMMANDFACTORY_H
+#define CLICOMMANDFACTORY_H
+
+#include <QString>
+#include <QHash>
+
+class CliCommand;
+
+class CliCommandFactory
+{
+    public:
+        static void init();
+        static CliCommand* getCommand(const QString& cmdName);
+        static QHash<QString,CliCommand*> getAllCommands();
+        static QStringList getCommandNames();
+
+    private:
+        typedef CliCommand* (*CliCommandCreatorFunc)();
+
+        static void registerCommand(CliCommandCreatorFunc func);
+
+        static QHash<QString,CliCommandCreatorFunc> mapping;
+};
+
+#endif // CLICOMMANDFACTORY_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.cpp
new file mode 100644
index 0000000..7a957c3
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.cpp
@@ -0,0 +1,86 @@
+#include "clicommandhelp.h"

+#include "clicommandfactory.h"

+#include "common/utils.h"

+#include "cli_config.h"

+

+void CliCommandHelp::execute()

+{

+    if (syntax.isArgumentSet(CMD_NAME))

+        printHelp(syntax.getArgument(CMD_NAME));

+    else

+        printHelp();

+}

+

+QString CliCommandHelp::shortHelp() const

+{

+    return tr("shows this help message");

+}

+

+QString CliCommandHelp::fullHelp() const

+{

+    return tr(

+                "Use %1 to learn about certain commands supported by the command line interface (CLI) of the SQLiteStudio.\n"

+                "To see list of supported commands, type %2 without any arguments.\n\n"

+                "When passing <command> name, you can skip special prefix character ('%3').\n\n"

+                "You can always execute any command with exactly single '--help' option to see help for that command. "

+                "It's an alternative for typing: %1 <command>."

+                ).arg(cmdName("help")).arg(cmdName("help")).arg(CFG_CLI.Console.CommandPrefixChar.get()).arg(cmdName("help"));

+}

+

+void CliCommandHelp::defineSyntax()

+{

+    syntax.setName("help");

+    syntax.addArgument(CMD_NAME, tr("command", "CLI command syntax"), false);

+}

+

+void CliCommandHelp::printHelp(const QString& cmd)

+{

+    QString cmdStr = cmd.startsWith(".") ? cmd.mid(1) : cmd;

+    CliCommand* command = CliCommandFactory::getCommand(cmdStr);

+    if (!command)

+    {

+        println(tr("No such command: %1").arg(cmd));

+        println(tr("Type '%1' for list of available commands.").arg(cmdName("help")));

+        println("");

+        return;

+    }

+    command->defineSyntax();

+    QStringList aliases = command->aliases();

+    QString prefix = CFG_CLI.Console.CommandPrefixChar.get();

+

+    QString msg;

+    msg += tr("Usage: %1%2").arg(prefix).arg(command->usage(cmdStr));

+    msg += "\n";

+    if (aliases.size() > 0)

+    {

+        if (aliases.contains(cmdStr))

+        {

+            aliases.removeOne(cmdStr);

+            aliases << command->getName();

+        }

+

+        msg += tr("Aliases: %1").arg(prefix + aliases.join(", " + prefix));

+        msg += "\n";

+    }

+    msg += "\n";

+    msg += command->fullHelp();

+    delete command;

+

+    printBox(msg);

+}

+

+void CliCommandHelp::printHelp()

+{

+    QHash<QString, CliCommand*> allCommands = CliCommandFactory::getAllCommands();

+    QStringList names = allCommands.keys();

+    int width = longest(names).size();

+

+    names.sort();

+    QStringList msgList;

+    foreach (const QString& cmd, names)

+    {

+        msgList << (CFG_CLI.Console.CommandPrefixChar.get() + pad(cmd, width, ' ') + " - " + allCommands[cmd]->shortHelp());

+        delete allCommands[cmd];

+    }

+    printBox(msgList.join("\n"));

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.h
new file mode 100644
index 0000000..c12c588
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhelp.h
@@ -0,0 +1,19 @@
+#ifndef CLICOMMANDHELP_H

+#define CLICOMMANDHELP_H

+

+#include "clicommand.h"

+

+class CliCommandHelp : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+

+    private:

+        void printHelp(const QString& cmd);

+        void printHelp();

+};

+

+#endif // CLICOMMANDHELP_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.cpp
new file mode 100644
index 0000000..fd2a494
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.cpp
@@ -0,0 +1,81 @@
+#include "clicommandhistory.h"

+#include "cli.h"

+#include "common/utils.h"

+#include "cliutils.h"

+#include "services/config.h"

+

+void CliCommandHistory::execute()

+{

+    if (syntax.isOptionSet(OPER_TYPE))

+    {

+        clear();

+        return;

+    }

+

+    if (syntax.isOptionSet(HIST_LIMIT))

+    {

+        setMax(syntax.getOptionValue(HIST_LIMIT));

+        return;

+    }

+

+    if (syntax.isOptionSet(SHOW_LIMIT))

+    {

+        println(tr("Current history limit is set to: %1").arg(CFG_CORE.Console.HistorySize.get()));

+        return;

+    }

+

+    int cols = getCliColumns();

+    QString hline = pad("", cols, '-');

+    foreach (const QString& line, cli->getHistory())

+    {

+        print(hline);

+        println(line);

+    }

+    println(hline);

+}

+

+QString CliCommandHistory::shortHelp() const

+{

+    return tr("prints history or erases it");

+}

+

+QString CliCommandHistory::fullHelp() const

+{

+    return tr(

+                "When no argument was passed, this command prints command line history. "

+                "Every history entry is separated with a horizontal line, so multiline entries are easier to read.\n"

+                "\n"

+                "When the -c or --clear option is passed, then the history gets erased.\n"

+                "When the -l or --limit option is passed, it sets the new history entries limit. It requires an additional argument"

+                "saying how many entries do you want the history to be limited to.\n"

+                "Use -ql or --querylimit option to see the current limit value."

+             );

+}

+

+void CliCommandHistory::defineSyntax()

+{

+    syntax.setName("history");

+    syntax.addOption(OPER_TYPE, "c", "clear");

+    syntax.addOptionWithArg(HIST_LIMIT, "l", "limit", tr("number"));

+    syntax.addOption(SHOW_LIMIT, "ql", "querylimit");

+}

+

+void CliCommandHistory::clear()

+{

+    cli->clearHistory();

+    println(tr("Console history erased."));

+}

+

+void CliCommandHistory::setMax(const QString& arg)

+{

+    bool ok;

+    int max = arg.toInt(&ok);

+    if (!ok)

+    {

+        println(tr("Invalid number: %1").arg(arg));

+        return;

+    }

+    CFG_CORE.Console.HistorySize.set(max);

+    cli->applyHistoryLimit();

+    println(tr("History limit set to %1").arg(max));

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.h
new file mode 100644
index 0000000..f2e07d0
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandhistory.h
@@ -0,0 +1,26 @@
+#ifndef CLICOMMANDHISTORY_H

+#define CLICOMMANDHISTORY_H

+

+#include "clicommand.h"

+

+class CliCommandHistory : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+

+    private:

+        enum ArgIds

+        {

+            OPER_TYPE,

+            HIST_LIMIT,

+            SHOW_LIMIT

+        };

+

+        void clear();

+        void setMax(const QString& arg);

+};

+

+#endif // CLICOMMANDHISTORY_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.cpp
new file mode 100644
index 0000000..b258045
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.cpp
@@ -0,0 +1,65 @@
+#include "clicommandmode.h"

+#include "common/unused.h"

+#include "cli_config.h"

+

+void CliCommandMode::execute()

+{

+    if (!syntax.isArgumentSet(MODE))

+    {

+        println(tr("Current results printing mode: %1").arg(CliResultsDisplay::mode(CFG_CLI.Console.ResultsDisplayMode.get())));

+        return;

+    }

+

+    CliResultsDisplay::Mode mode = CliResultsDisplay::mode(syntax.getArgument(MODE).toUpper());

+    if (syntax.getArgument(MODE).toUpper() != CliResultsDisplay::mode(mode))

+    {

+        println(tr("Invalid results printing mode: %1").arg(syntax.getArgument(MODE).toUpper()));

+        return;

+    }

+

+    CFG_CLI.Console.ResultsDisplayMode.set(mode);

+    println(tr("New results printing mode: %1").arg(CliResultsDisplay::mode(mode)));

+}

+

+QString CliCommandMode::shortHelp() const

+{

+    return tr("tells or changes the query results format");

+}

+

+QString CliCommandMode::fullHelp() const

+{

+    return tr(

+                "When called without argument, tells the current output format for a query results. "

+                "When the <mode> is passed, the mode is changed to the given one. "

+                "Supported modes are:\n"

+                "- CLASSIC - columns are separated by a comma, not aligned,\n"

+                "- FIXED   - columns have equal and fixed width, they always fit into terminal window width, but the data in columns can be cut off,\n"

+                "- COLUMNS - like FIXED, but smarter (do not use with huge result sets, see details below),\n"

+                "- ROW     - each column from the row is displayed in new line, so the full data is displayed.\n"

+                "\n"

+                "The CLASSIC mode is recommended if you want to see all the data, but you don't want to waste lines for each column. "

+                "Each row will display full data for every column, but this also means, that columns will not be aligned to each other in next rows. "

+                "The CLASSIC mode also doesn't respect the width of your terminal (console) window, so if values in columns are wider than the window, "

+                "the row will be continued in next lines.\n"

+                "\n"

+                "The FIXED mode is recommended if you want a readable output and you don't care about long data values. "

+                "Columns will be aligned, making the output a nice table. The width of columns is calculated from width of the console window "

+                "and a number of columns.\n"

+                "\n"

+                "The COLUMNS mode is similar to FIXED mode, except it tries to be smart and make columns with shorter values more thin, "

+                "while columns with longer values get more space. First to shrink are columns with longest headers (so the header names are to be "

+                "cut off as first), then columns with the longest values are shrinked, up to the moment when all columns fit into terminal window.\n"

+                "ATTENTION! The COLUMNS mode reads all the results from the query at once in order to evaluate column widhts, therefore it is dangerous "

+                "to use this mode when working with huge result sets. Keep in mind that this mode will load entire result set into memory.\n"

+                "\n"

+                "The ROW mode is recommended if you need to see whole values and you don't expect many rows to be displayed, because this mode "

+                "displays a line of output per each column, so you'll get 10 lines for single row with 10 columns, then if you have 10 of such rows, "

+                "you will get 100 lines of output (+1 extra line per each row, to separate rows from each other)."

+                );

+}

+

+void CliCommandMode::defineSyntax()

+{

+    syntax.setName("mode");

+    syntax.addStrictArgument(MODE, {"classic", "fixed", "columns", "row"}, false);

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.h
new file mode 100644
index 0000000..2b087d3
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandmode.h
@@ -0,0 +1,21 @@
+#ifndef CLICOMMANDMODE_H

+#define CLICOMMANDMODE_H

+

+#include "clicommand.h"

+

+class CliCommandMode : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+

+    private:

+        enum ArgIgs

+        {

+            MODE

+        };

+};

+

+#endif // CLICOMMANDMODE_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.cpp
new file mode 100644
index 0000000..9616d9e
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.cpp
@@ -0,0 +1,32 @@
+#include "clicommandnullvalue.h"

+#include "cli_config.h"

+

+void CliCommandNullValue::execute()

+{

+    if (syntax.isArgumentSet(STRING))

+        CFG_CLI.Console.NullValue.set(syntax.getArgument(STRING));

+

+    println(tr("Current NULL representation string: %1").arg(CFG_CLI.Console.NullValue.get()));

+    return;

+}

+

+QString CliCommandNullValue::shortHelp() const

+{

+    return tr("tells or changes the NULL representation string");

+}

+

+QString CliCommandNullValue::fullHelp() const

+{

+    return tr(

+                "If no argument was passed, it tells what's the current NULL value representation "

+                "(that is - what is printed in place of NULL values in query results). "

+                "If the argument is given, then it's used as a new string to be used for NULL representation."

+                );

+}

+

+void CliCommandNullValue::defineSyntax()

+{

+    syntax.setName("null");

+    syntax.addAlias("nullvalue");

+    syntax.addArgument(STRING, QObject::tr("string", "CLI command syntax"), false);

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.h
new file mode 100644
index 0000000..4ac4699
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandnullvalue.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDNULLVALUE_H

+#define CLICOMMANDNULLVALUE_H

+

+#include "clicommand.h"

+

+class CliCommandNullValue : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+};

+

+#endif // CLICOMMANDNULLVALUE_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.cpp
new file mode 100644
index 0000000..fef1737
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.cpp
@@ -0,0 +1,84 @@
+#include "clicommandopen.h"
+#include "cli.h"
+#include "services/dbmanager.h"
+#include <QFile>
+#include <QDir>
+#include <QDebug>
+
+void CliCommandOpen::execute()
+{
+    if (!syntax.isArgumentSet(DB_NAME_OR_FILE) && !cli->getCurrentDb())
+    {
+        println(tr("Cannot call %1 when no database is set to be current. Specify current database with %2 command or pass database name to %3.")
+                .arg(cmdName("open")).arg(cmdName("use")).arg(cmdName("open")));
+        return;
+    }
+
+    Db* db = nullptr;
+    if (syntax.isArgumentSet(DB_NAME_OR_FILE))
+    {
+        QString arg = syntax.getArgument(DB_NAME_OR_FILE);
+        db = DBLIST->getByName(arg);
+        if (!db)
+        {
+            if (QFile::exists(arg))
+            {
+                QString newName = DbManager::generateDbName(arg);
+                if (!DBLIST->addDb(newName, arg, false))
+                {
+                    println(tr("Could not add database %1 to list.").arg(arg));
+                    return;
+                }
+                db = DBLIST->getByName(arg);
+                Q_ASSERT(db != nullptr);
+            }
+            else
+            {
+                println(tr("File %1 doesn't exist in %2. Cannot open inexisting database with %3 command. "
+                                "To create a new database, use %4 command.").arg(arg).arg(QDir::currentPath())
+                        .arg(cmdName("open")).arg(cmdName("add")));
+                return;
+            }
+        }
+    }
+    else
+    {
+        db = cli->getCurrentDb();
+        if (!db)
+        {
+            qCritical() << "Default database is not in the list!";
+            return ;
+        }
+    }
+
+    if (!db->open())
+    {
+        println(db->getErrorText());
+        return;
+    }
+
+    cli->setCurrentDb(db);
+    println(tr("Database %1 has been open and set as the current working database.").arg(db->getName()));
+}
+
+QString CliCommandOpen::shortHelp() const
+{
+    return tr("opens database connection");
+}
+
+QString CliCommandOpen::fullHelp() const
+{
+    return tr(
+                "Opens connection to the database. If no additional argument was passed, then the connection is open to the "
+                "current default database (see help for %1 for details). However if an argument was passed, it can be either "
+                "<name> of the registered database to open, or it can be <path> to the database file to open. "
+                "In the second case, the <path> gets registered on the list with a generated name, but only for the period "
+                "of current application session. After restarting application such database is not restored on the list."
+             ).arg(cmdName("use"));
+}
+
+void CliCommandOpen::defineSyntax()
+{
+    syntax.setName("open");
+    syntax.addAlternatedArgument(DB_NAME_OR_FILE, {tr("name", "CLI command syntax"), tr("path", "CLI command syntax")}, false);
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.h
new file mode 100644
index 0000000..e66f574
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandopen.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDOPEN_H
+#define CLICOMMANDOPEN_H
+
+#include "clicommand.h"
+
+class CliCommandOpen : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDOPEN_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.cpp
new file mode 100644
index 0000000..f96cae4
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.cpp
@@ -0,0 +1,28 @@
+#include "clicommandpwd.h"

+#include "common/unused.h"

+#include <QDir>

+

+void CliCommandPwd::execute()

+{

+    QDir dir;

+    println(dir.absolutePath());

+}

+

+QString CliCommandPwd::shortHelp() const

+{

+    return tr("prints the current working directory");

+}

+

+QString CliCommandPwd::fullHelp() const

+{

+    return tr(

+                "This is the same as 'pwd' command on Unix systems and 'cd' command without arguments on Windows. "

+                "It prints current working directory. You can change the current working directory with %1 command "

+                "and you can also list contents of the current working directory with %2 command."

+                ).arg(cmdName("cd")).arg(cmdName("dir"));

+}

+

+void CliCommandPwd::defineSyntax()

+{

+    syntax.setName("pwd");

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.h
new file mode 100644
index 0000000..3568ce1
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandpwd.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDPWD_H

+#define CLICOMMANDPWD_H

+

+#include "clicommand.h"

+

+class CliCommandPwd : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+};

+

+#endif // CLICOMMANDPWD_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.cpp
new file mode 100644
index 0000000..6474a78
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.cpp
@@ -0,0 +1,51 @@
+#include "clicommandremove.h"
+#include "cli.h"
+#include "services/dbmanager.h"
+#include "db/db.h"
+
+void CliCommandRemove::execute()
+{
+    QString dbName = syntax.getArgument(DB_NAME);
+    Db* db = DBLIST->getByName(dbName);
+    if (!db)
+    {
+        println(tr("No such database: %1").arg(dbName));
+        return;
+    }
+
+    bool isCurrent = cli->getCurrentDb() == db;
+    QString name = db->getName();
+
+    DBLIST->removeDb(db);
+    println(tr("Database removed: %1").arg(name));
+
+    QList<Db*> dblist = DBLIST->getDbList();
+    if (isCurrent && dblist.size() > 0)
+    {
+        cli->setCurrentDb(dblist[0]);
+        println(tr("New current database set:"));
+        println(cli->getCurrentDb()->getName());
+    }
+    else
+        cli->setCurrentDb(nullptr);
+}
+
+QString CliCommandRemove::shortHelp() const
+{
+    return tr("removes database from the list");
+}
+
+QString CliCommandRemove::fullHelp() const
+{
+    return tr(
+                "Removes <name> database from the list of registered databases. "
+                "If the database was not on the list (see %1 command), then error message is printed "
+                "and nothing more happens."
+                ).arg(cmdName("dblist"));
+}
+
+void CliCommandRemove::defineSyntax()
+{
+    syntax.setName("remove");
+    syntax.addArgument(DB_NAME, tr("name", "CLI command syntax"));
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.h
new file mode 100644
index 0000000..f4b5402
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandremove.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDREMOVE_H
+#define CLICOMMANDREMOVE_H
+
+#include "clicommand.h"
+
+class CliCommandRemove : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDREMOVE_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.cpp
new file mode 100644
index 0000000..3f2c4b3
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.cpp
@@ -0,0 +1,506 @@
+#include "clicommandsql.h"
+#include "cli.h"
+#include "parser/ast/sqliteselect.h"
+#include "parser/parser.h"
+#include "parser/parsererror.h"
+#include "db/queryexecutor.h"
+#include "qio.h"
+#include "common/unused.h"
+#include "cli_config.h"
+#include "cliutils.h"
+#include <QList>
+#include <QDebug>
+
+void CliCommandSql::execute()
+{
+    if (!cli->getCurrentDb())
+    {
+        println(tr("No working database is set.\n"
+                   "Call %1 command to set working database.\n"
+                   "Call %2 to see list of all databases.")
+                .arg(cmdName("use")).arg(cmdName("dblist")));
+
+        return;
+    }
+
+    Db* db = cli->getCurrentDb();
+    if (!db || !db->isOpen())
+    {
+        println(tr("Database is not open."));
+        return;
+    }
+
+    // Executor deletes itself later when called with lambda.
+    QueryExecutor *executor = new QueryExecutor(db, syntax.getArgument(STRING));
+    connect(executor, SIGNAL(executionFinished(SqlQueryPtr)), this, SIGNAL(execComplete()));
+    connect(executor, SIGNAL(executionFailed(int,QString)), this, SLOT(executionFailed(int,QString)));
+    connect(executor, SIGNAL(executionFailed(int,QString)), this, SIGNAL(execComplete()));
+
+    executor->exec([=](SqlQueryPtr results)
+    {
+        if (results->isError())
+            return; // should not happen, since results handler function is called only for successful executions
+
+        switch (CFG_CLI.Console.ResultsDisplayMode.get())
+        {
+            case CliResultsDisplay::FIXED:
+                printResultsFixed(executor, results);
+                break;
+            case CliResultsDisplay::COLUMNS:
+                printResultsColumns(executor, results);
+                break;
+            case CliResultsDisplay::ROW:
+                printResultsRowByRow(executor, results);
+                break;
+            default:
+                printResultsClassic(executor, results);
+                break;
+        }
+    });
+}
+
+QString CliCommandSql::shortHelp() const
+{
+    return tr("executes SQL query");
+}
+
+QString CliCommandSql::fullHelp() const
+{
+    return tr(
+                "This command is executed every time you enter SQL query in command prompt. "
+                "It executes the query on the current working database (see help for %1 for details). "
+                "There's no sense in executing this command explicitly. Instead just type the SQL query "
+                "in the command prompt, without any command prefixed."
+                ).arg(cmdName("use"));
+}
+
+bool CliCommandSql::isAsyncExecution() const
+{
+    return true;
+}
+
+void CliCommandSql::defineSyntax()
+{
+    syntax.setName("query");
+    syntax.addArgument(STRING, tr("sql", "CLI command syntax"));
+    syntax.setStrictArgumentCount(false);
+}
+
+void CliCommandSql::printResultsClassic(QueryExecutor* executor, SqlQueryPtr results)
+{
+    int metaColumns = executor->getMetaColumnCount();
+    int resultColumnCount = executor->getResultColumns().size();
+
+    // Columns
+    foreach (const QueryExecutor::ResultColumnPtr& resCol, executor->getResultColumns())
+        qOut << resCol->displayName << "|";
+
+    qOut << "\n";
+
+    // Data
+    SqlResultsRowPtr row;
+    QList<QVariant> values;
+    int i;
+    while (results->hasNext())
+    {
+        row = results->next();
+        i = 0;
+        values = row->valueList().mid(metaColumns);
+        foreach (QVariant value, values)
+        {
+            qOut << getValueString(value);
+            if ((i + 1) < resultColumnCount)
+                qOut << "|";
+
+            i++;
+        }
+
+        qOut << "\n";
+    }
+    qOut.flush();
+}
+
+void CliCommandSql::printResultsFixed(QueryExecutor* executor, SqlQueryPtr results)
+{
+    QList<QueryExecutor::ResultColumnPtr> resultColumns = executor->getResultColumns();
+    int resultColumnsCount = resultColumns.size();
+    int metaColumns = executor->getMetaColumnCount();
+    int termCols = getCliColumns();
+    int baseColWidth = termCols / resultColumns.size() - 1;
+
+    if (resultColumnsCount == 0)
+        return;
+
+    if ((resultColumnsCount * 2 - 1) > termCols)
+    {
+        println(tr("Too many columns to display in %1 mode.").arg("FIXED"));
+        return;
+    }
+
+    int width;
+    QList<int> widths;
+    for (int i = 0; i < resultColumnsCount; i++)
+    {
+        width = baseColWidth;
+        if (i+1 == resultColumnsCount)
+            width += (termCols - resultColumnsCount * (baseColWidth + 1) + 1);
+
+        widths << width;
+    }
+
+    // Columns
+    QStringList columns;
+    foreach (const QueryExecutor::ResultColumnPtr& resCol, executor->getResultColumns())
+        columns << resCol->displayName;
+
+    printColumnHeader(widths, columns);
+
+    // Data
+    while (results->hasNext())
+        printColumnDataRow(widths, results->next(), metaColumns);
+
+    qOut.flush();
+}
+
+void CliCommandSql::printResultsColumns(QueryExecutor* executor, SqlQueryPtr results)
+{
+    // Check if we don't have more columns than we can display
+    QList<QueryExecutor::ResultColumnPtr> resultColumns = executor->getResultColumns();
+    int termCols = getCliColumns();
+    int resultColumnsCount = resultColumns.size();
+    QStringList headerNames;
+    if (resultColumnsCount == 0)
+        return;
+
+    // Every column requires at least 1 character width + column separators between them
+    if ((resultColumnsCount * 2 - 1) > termCols)
+    {
+        println(tr("Too many columns to display in %1 mode.").arg("COLUMNS"));
+        return;
+    }
+
+    // Preload data (we will calculate column widths basing on real values)
+    QList<SqlResultsRowPtr> allRows = results->getAll();
+    int metaColumns = executor->getMetaColumnCount();
+
+    // Get widths of each column in every data row, remember the longest ones
+    QList<SortedColumnWidth*> columnWidths;
+    SortedColumnWidth* colWidth = nullptr;
+    foreach (const QueryExecutor::ResultColumnPtr& resCol, resultColumns)
+    {
+        colWidth = new SortedColumnWidth();
+        colWidth->setHeaderWidth(resCol->displayName.length());
+        columnWidths << colWidth;
+        headerNames << resCol->displayName;
+    }
+
+    int dataLength;
+    foreach (const SqlResultsRowPtr& row, allRows)
+    {
+        for (int i = 0; i < resultColumnsCount; i++)
+        {
+            dataLength = row->value(metaColumns + i).toString().length();
+            columnWidths[i]->setMinDataWidth(dataLength);
+        }
+    }
+
+    // Calculate width as it would be required to display entire rows
+    int totalWidth = 0;
+    foreach (colWidth, columnWidths)
+        totalWidth += colWidth->getWidth();
+
+    totalWidth += (resultColumnsCount - 1); // column separators
+
+    // Adjust column sizes to fit into terminal window
+    if (totalWidth < termCols)
+    {
+        // Expanding last column
+        int diff = termCols - totalWidth;
+        columnWidths.last()->incrWidth(diff);
+    }
+    else if (totalWidth > termCols)
+    {
+        // Shrinking columns
+        shrinkColumns(columnWidths, termCols, resultColumnsCount, totalWidth);
+    }
+
+    // Printing
+    QList<int> finalWidths;
+    foreach (colWidth, columnWidths)
+        finalWidths << colWidth->getWidth();
+
+    printColumnHeader(finalWidths, headerNames);
+
+    foreach (SqlResultsRowPtr row, allRows)
+        printColumnDataRow(finalWidths, row, metaColumns);
+
+    qOut.flush();
+}
+
+void CliCommandSql::printResultsRowByRow(QueryExecutor* executor, SqlQueryPtr results)
+{
+    // Columns
+    int metaColumns = executor->getMetaColumnCount();
+    int colWidth = 0;
+    foreach (const QueryExecutor::ResultColumnPtr& resCol, executor->getResultColumns())
+    {
+        if (resCol->displayName.length() > colWidth)
+            colWidth = resCol->displayName.length();
+    }
+
+    QStringList columns;
+    foreach (const QueryExecutor::ResultColumnPtr& resCol, executor->getResultColumns())
+        columns << pad(resCol->displayName, -colWidth, ' ');
+
+    // Data
+    static const QString rowCntTemplate = tr("Row %1");
+    int termWidth = getCliColumns();
+    QString rowCntString;
+    int i;
+    int rowCnt = 1;
+    SqlResultsRowPtr row;
+    while (results->hasNext())
+    {
+        row = results->next();
+        i = 0;
+        rowCntString = " " + rowCntTemplate.arg(rowCnt) + " ";
+        qOut << center(rowCntString, termWidth - 1, '-') << "\n";
+        foreach (QVariant value, row->valueList().mid(metaColumns))
+        {
+            qOut << columns[i] + ": " + getValueString(value) << "\n";
+            i++;
+        }
+        rowCnt++;
+    }
+    qOut.flush();
+}
+
+void CliCommandSql::shrinkColumns(QList<CliCommandSql::SortedColumnWidth*>& columnWidths, int termCols, int resultColumnsCount, int totalWidth)
+{
+    // This implements quite a smart shrinking algorithm:
+    // All columns are sorted by their current total width (data and header width)
+    // and then longest headers are shrinked first, then if headers are no longer a problem,
+    // but the data is - then longest data values are shrinked.
+    // If either the hader or the data value is huge (way more than fits into terminal),
+    // then such column is shrinked in one step to a reasonable width, so it can be later
+    // shrinked more precisely.
+    int maxSingleColumnWidth = (termCols - (resultColumnsCount - 1) * 2 );
+    bool shrinkData;
+    int previousTotalWidth = -1;
+    while (totalWidth > termCols && totalWidth != previousTotalWidth)
+    {
+        shrinkData = true;
+        previousTotalWidth = totalWidth;
+
+        // Sort columns by current widths
+        qSort(columnWidths);
+
+        // See if we can shrink headers only, or we already need to shrink the data
+        foreach (SortedColumnWidth* colWidth, columnWidths)
+        {
+            if (colWidth->isHeaderLonger())
+            {
+                shrinkData = false;
+                break;
+            }
+        }
+
+        // Do the shrinking
+        if (shrinkData)
+        {
+            for (int i = resultColumnsCount - 1; i >= 0; i--)
+            {
+                // If the data is way larger then the terminal, shrink it to reasonable length in one step.
+                // We also make sure that after data shrinking, the header didn't become longer than the data,
+                // cause at this moment, we were finished with headers and we enforce shrinking data
+                // and so do with headers.
+                if (columnWidths[i]->getDataWidth() > maxSingleColumnWidth)
+                {
+                    totalWidth -= (columnWidths[i]->getDataWidth() - maxSingleColumnWidth);
+                    columnWidths[i]->setDataWidth(maxSingleColumnWidth);
+                    columnWidths[i]->setMaxHeaderWidth(maxSingleColumnWidth);
+                    break;
+                }
+                else if (columnWidths[i]->getDataWidth() > 1) // just shrink it by 1
+                {
+                    totalWidth -= 1;
+                    columnWidths[i]->decrDataWidth();
+                    columnWidths[i]->setMaxHeaderWidth(columnWidths[i]->getDataWidth());
+                    break;
+                }
+            }
+        }
+        else // shrinking headers
+        {
+            for (int i = resultColumnsCount - 1; i >= 0; i--)
+            {
+                // We will shrink only the header that
+                if (!columnWidths[i]->isHeaderLonger())
+                    continue;
+
+                // If the header is way larger then the terminal, shrink it to reasonable length in one step
+                if (columnWidths[i]->getHeaderWidth() > maxSingleColumnWidth)
+                {
+                    totalWidth -= (columnWidths[i]->getHeaderWidth() - maxSingleColumnWidth);
+                    columnWidths[i]->setHeaderWidth(maxSingleColumnWidth);
+                    break;
+                }
+                else if (columnWidths[i]->getHeaderWidth() > 1) // otherwise just shrink it by 1
+                {
+                    totalWidth -= 1;
+                    columnWidths[i]->decrHeaderWidth();
+                    break;
+                }
+            }
+        }
+    }
+
+    if (totalWidth == previousTotalWidth && totalWidth > termCols)
+        qWarning() << "The shrinking algorithm in printResultsColumns() failed, it could not shrink columns enough.";
+}
+
+void CliCommandSql::printColumnHeader(const QList<int>& widths, const QStringList& columns)
+{
+    QStringList line;
+    int i = 0;
+    foreach (const QString& col, columns)
+    {
+        line << pad(col.left(widths[i]), widths[i], ' ');
+        i++;
+    }
+
+    qOut << line.join("|");
+
+    line.clear();
+    QString hline("-");
+    for (i = 0; i < columns.count(); i++)
+        line << hline.repeated(widths[i]);
+
+    qOut << line.join("+");
+}
+
+void CliCommandSql::printColumnDataRow(const QList<int>& widths, const SqlResultsRowPtr& row, int rowIdOffset)
+{
+    int i = 0;
+    QStringList line;
+    foreach (const QVariant& value, row->valueList().mid(rowIdOffset))
+    {
+        line << pad(getValueString(value).left(widths[i]), widths[i], ' ');
+        i++;
+    }
+
+    qOut << line.join("|");
+}
+
+QString CliCommandSql::getValueString(const QVariant& value)
+{
+    if (value.isValid() && !value.isNull())
+        return value.toString();
+
+    return CFG_CLI.Console.NullValue.get();
+}
+
+void CliCommandSql::executionFailed(int code, const QString& msg)
+{
+    UNUSED(code);
+    qOut << tr("Query execution error: %1").arg(msg) << "\n\n";
+    qOut.flush();
+}
+
+CliCommandSql::SortedColumnWidth::SortedColumnWidth()
+{
+    dataWidth = 0;
+    headerWidth = 0;
+    width = 0;
+}
+
+bool CliCommandSql::SortedColumnWidth::operator<(const CliCommandSql::SortedColumnWidth& other)
+{
+    return width < other.width;
+}
+
+int CliCommandSql::SortedColumnWidth::getHeaderWidth() const
+{
+    return headerWidth;
+}
+
+void CliCommandSql::SortedColumnWidth::setHeaderWidth(int value)
+{
+    headerWidth = value;
+    updateWidth();
+}
+
+void CliCommandSql::SortedColumnWidth::setMaxHeaderWidth(int value)
+{
+    if (headerWidth > value)
+    {
+        headerWidth = value;
+        updateWidth();
+    }
+}
+
+void CliCommandSql::SortedColumnWidth::incrHeaderWidth(int value)
+{
+    headerWidth += value;
+    updateWidth();
+}
+
+void CliCommandSql::SortedColumnWidth::decrHeaderWidth(int value)
+{
+    headerWidth -= value;
+    updateWidth();
+}
+
+int CliCommandSql::SortedColumnWidth::getDataWidth() const
+{
+    return dataWidth;
+}
+
+void CliCommandSql::SortedColumnWidth::setDataWidth(int value)
+{
+    dataWidth = value;
+    updateWidth();
+}
+
+void CliCommandSql::SortedColumnWidth::setMinDataWidth(int value)
+{
+    if (dataWidth < value)
+    {
+        dataWidth = value;
+        updateWidth();
+    }
+}
+
+void CliCommandSql::SortedColumnWidth::incrDataWidth(int value)
+{
+    dataWidth += value;
+    updateWidth();
+}
+
+void CliCommandSql::SortedColumnWidth::decrDataWidth(int value)
+{
+    dataWidth -= value;
+    updateWidth();
+}
+
+void CliCommandSql::SortedColumnWidth::incrWidth(int value)
+{
+    width += value;
+    dataWidth = width;
+    headerWidth = width;
+}
+
+int CliCommandSql::SortedColumnWidth::getWidth() const
+{
+    return width;
+}
+
+bool CliCommandSql::SortedColumnWidth::isHeaderLonger() const
+{
+    return headerWidth > dataWidth;
+}
+
+void CliCommandSql::SortedColumnWidth::updateWidth()
+{
+    width = qMax(headerWidth, dataWidth);
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.h
new file mode 100644
index 0000000..5423a85
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandsql.h
@@ -0,0 +1,66 @@
+#ifndef CLICOMMANDSQL_H
+#define CLICOMMANDSQL_H
+
+#include "clicommand.h"
+#include "db/sqlquery.h"
+
+class QueryExecutor;
+
+class CliCommandSql : public CliCommand
+{
+        Q_OBJECT
+
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        bool isAsyncExecution() const;
+        void defineSyntax();
+
+    private:
+        class SortedColumnWidth
+        {
+            public:
+                SortedColumnWidth();
+
+                bool operator<(const SortedColumnWidth& other);
+
+                int getHeaderWidth() const;
+                void setHeaderWidth(int value);
+                void setMaxHeaderWidth(int value);
+                void incrHeaderWidth(int value = 1);
+                void decrHeaderWidth(int value = 1);
+
+                int getDataWidth() const;
+                void setDataWidth(int value);
+                void setMinDataWidth(int value);
+                void incrDataWidth(int value = 1);
+                void decrDataWidth(int value = 1);
+
+                void incrWidth(int value = 0);
+                int getWidth() const;
+                bool isHeaderLonger() const;
+
+            private:
+                void updateWidth();
+
+                int width;
+                int headerWidth;
+                int dataWidth;
+        };
+
+        void printResultsClassic(QueryExecutor *executor, SqlQueryPtr results);
+        void printResultsFixed(QueryExecutor *executor, SqlQueryPtr results);
+        void printResultsColumns(QueryExecutor *executor, SqlQueryPtr results);
+        void printResultsRowByRow(QueryExecutor *executor, SqlQueryPtr results);
+        void shrinkColumns(QList<SortedColumnWidth*>& columnWidths, int termCols, int resultColumnsCount, int totalWidth);
+        void printColumnHeader(const QList<int>& widths, const QStringList& columns);
+        void printColumnDataRow(const QList<int>& widths, const SqlResultsRowPtr& row, int rowIdOffset);
+
+        QString getValueString(const QVariant& value);
+
+    private slots:
+        void executionFailed(int code, const QString& msg);
+};
+
+#endif // CLICOMMANDSQL_H
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.cpp
new file mode 100644
index 0000000..9a6b325
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.cpp
@@ -0,0 +1,79 @@
+#include "clicommandtables.h"

+#include "cli.h"

+#include "schemaresolver.h"

+#include "services/dbmanager.h"

+#include "common/utils.h"

+

+void CliCommandTables::execute()

+{

+    Db* db = nullptr;

+    if (syntax.isArgumentSet(DB_NAME))

+    {

+        db = DBLIST->getByName(syntax.getArgument(DB_NAME));

+        if (!db)

+        {

+            println(tr("No such database: %1. Use .dblist to see list of known databases.").arg(syntax.getArgument(DB_NAME)));

+            return;

+        }

+    }

+    else if (cli->getCurrentDb())

+    {

+        db = cli->getCurrentDb();

+    }

+    else

+    {

+        println(tr("Cannot call %1 when no database is set to be current. Specify current database with %2 command or pass database name to %3.")

+                .arg(cmdName("tables")).arg(cmdName("use")).arg(cmdName("tables")));

+        return;

+    }

+

+    if (!db->isOpen())

+    {

+        println(tr("Database %1 is closed.").arg(db->getName()));

+        return;

+    }

+

+    println();

+

+    SchemaResolver resolver(db);

+    resolver.setIgnoreSystemObjects(!syntax.isOptionSet(SHOW_SYSTEM_TABLES));

+    QSet<QString> dbList;

+    dbList << "main" << "temp";

+    dbList += resolver.getDatabases();

+

+    int width = longest(dbList.toList()).length();

+    width = qMax(width, tr("Database").length());

+

+    println(pad(tr("Database"), width, ' ') + " " + tr("Table"));

+    println(pad("", width, '-') + "-------------------");

+

+    foreach (const QString& dbName, dbList)

+    {

+        foreach (const QString& table, resolver.getTables(dbName))

+            println(pad(dbName, width, ' ') + " " + table);

+    }

+

+    println();

+}

+

+QString CliCommandTables::shortHelp() const

+{

+    return tr("prints list of tables in the database");

+}

+

+QString CliCommandTables::fullHelp() const

+{

+    return tr(

+                "Prints list of tables in given <database> or in the current working database. "

+                "Note, that the <database> should be the name of the registered database (see %1). "

+                "The output list includes all tables from any other databases attached to the queried database.\n"

+                "When the -s option is given, then system tables are also listed."

+                ).arg(cmdName("use"));

+}

+

+void CliCommandTables::defineSyntax()

+{

+    syntax.setName("tables");

+    syntax.addArgument(DB_NAME, tr("database", "CLI command syntax"), false);

+    syntax.addOptionShort(SHOW_SYSTEM_TABLES, "s");

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.h
new file mode 100644
index 0000000..68ae314
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtables.h
@@ -0,0 +1,21 @@
+#ifndef CLICOMMANDTABLES_H

+#define CLICOMMANDTABLES_H

+

+#include "clicommand.h"

+

+class CliCommandTables : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+

+    private:

+        enum ArgIds

+        {

+            SHOW_SYSTEM_TABLES

+        };

+};

+

+#endif // CLICOMMANDTABLES_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.cpp
new file mode 100644
index 0000000..cbd57c6
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.cpp
@@ -0,0 +1,154 @@
+#include "clicommandtree.h"

+#include "cli.h"

+#include "common/sortedhash.h"

+#include "common/unused.h"

+

+const QString CliCommandTree::metaNodeNameTemplate = "<%1>";

+

+void CliCommandTree::execute()

+{

+    if (!cli->getCurrentDb())

+    {

+        println(tr("No current working database is selected. Use %1 to define one and then run %2.").arg(cmdName("use")).arg(cmdName("tree")));

+        return;

+    }

+

+    bool printColumns = syntax.isOptionSet(COLUMNS);

+    bool printSystemObjects = syntax.isOptionSet(SYSTEM_OBJECTS);

+

+    SchemaResolver resolver(cli->getCurrentDb());

+    resolver.setIgnoreSystemObjects(!printSystemObjects);

+

+    QStringList databases;

+    if (syntax.isArgumentSet(INTRNAL_DB))

+    {

+        databases << syntax.getArgument(INTRNAL_DB);

+    }

+    else

+    {

+        databases << "main" << "temp";

+        databases += resolver.getDatabases().toList();

+    }

+

+    AsciiTree tree;

+    tree.label = cli->getCurrentDb()->getName();

+    foreach (const QString& database, databases)

+    {

+        tree.childs << getDatabaseTree(database, resolver, printColumns);

+    }

+

+    println();

+    println(toAsciiTree(tree));

+    println();

+}

+

+AsciiTree CliCommandTree::getDatabaseTree(const QString& database, SchemaResolver& resolver, bool printColumns)

+{

+    QStringList tables = resolver.getTables(database);

+    QStringList views = resolver.getViews(database);

+

+    AsciiTree tree;

+    AsciiTree tablesTree;

+    AsciiTree viewsTree;

+

+    tablesTree.label = metaNodeNameTemplate.arg(tr("Tables"));

+    foreach (const QString& table, tables)

+        tablesTree.childs << getTableTree(database, table, resolver, printColumns);

+

+    viewsTree.label = metaNodeNameTemplate.arg(tr("Views"));

+    foreach (const QString& view, views)

+        viewsTree.childs << getViewTree(database, view, resolver);

+

+    tree.label = database;

+    tree.childs << tablesTree << viewsTree;

+    return tree;

+}

+

+AsciiTree CliCommandTree::getTableTree(const QString& database, const QString& table, SchemaResolver& resolver, bool printColumns)

+{

+    QStringList columns;

+    if (printColumns)

+        columns = resolver.getTableColumns(database, table);

+

+    QStringList indexes = resolver.getIndexesForTable(database, table);

+    QStringList triggers = resolver.getTriggersForTable(database, table);

+

+    AsciiTree tree;

+    AsciiTree columnsTree;

+    AsciiTree indexesTree;

+    AsciiTree triggersTree;

+

+    if (printColumns)

+    {

+        columnsTree.label = metaNodeNameTemplate.arg(tr("Columns"));

+        foreach (const QString& column, columns)

+            columnsTree.childs << getTreeLeaf(column);

+    }

+

+    indexesTree.label = metaNodeNameTemplate.arg(tr("Indexes"));

+    foreach (const QString& index, indexes)

+        indexesTree.childs << getTreeLeaf(index);

+

+    triggersTree.label = metaNodeNameTemplate.arg(tr("Triggers"));

+    foreach (const QString& trig, triggers)

+        triggersTree.childs << getTreeLeaf(trig);

+

+    if (printColumns)

+        tree.childs << columnsTree;

+

+    tree.label = table;

+    tree.childs << indexesTree;

+    tree.childs << triggersTree;

+

+    return tree;

+}

+

+AsciiTree CliCommandTree::getViewTree(const QString& database, const QString& view, SchemaResolver& resolver)

+{

+    QStringList triggers = resolver.getTriggersForView(database, view);

+

+    AsciiTree tree;

+    AsciiTree triggersTree;

+

+    triggersTree.label = metaNodeNameTemplate.arg(tr("Triggers"));

+    foreach (const QString& trig, triggers)

+        triggersTree.childs << getTreeLeaf(trig);

+

+    tree.label = view;

+    tree.childs << triggersTree;

+

+    return tree;

+}

+

+AsciiTree CliCommandTree::getTreeLeaf(const QString& column)

+{

+    AsciiTree tree;

+    tree.label = column;

+    return tree;

+}

+

+QString CliCommandTree::shortHelp() const

+{

+    return tr("prints all objects in the database as a tree");

+}

+

+QString CliCommandTree::fullHelp() const

+{

+    return tr(

+                "Prints all objects (tables, indexes, triggers and views) that are in the database as a tree. "

+                "The tree is very similar to the one that you can see in GUI client of the SQLiteStudio.\n"

+                "When -c option is given, then also columns will be listed under each table.\n"

+                "When -s option is given, then also system objects will be printed (sqlite_* tables, autoincrement indexes, etc).\n"

+                "The database argument is optional and if provided, then only given database will be printed. This is not a registered database name, "

+                "but instead it's an internal SQLite database name, like 'main', 'temp', or any attached database name. To print tree for other "

+                "registered database, call %1 first to switch the working database, and then use %2 command."

+             ).arg(cmdName("use")).arg(cmdName("tree"));

+}

+

+void CliCommandTree::defineSyntax()

+{

+    syntax.setName("tree");

+    syntax.addOptionShort(COLUMNS, "c");

+    syntax.addOptionShort(SYSTEM_OBJECTS, "s");

+    syntax.addArgument(INTRNAL_DB, "database", false);

+}

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.h
new file mode 100644
index 0000000..815d781
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommandtree.h
@@ -0,0 +1,31 @@
+#ifndef CLICOMMANDTREE_H

+#define CLICOMMANDTREE_H

+

+#include "schemaresolver.h"

+#include "cliutils.h"

+#include "clicommand.h"

+

+class CliCommandTree : public CliCommand

+{

+    public:

+        void execute();

+        QString shortHelp() const;

+        QString fullHelp() const;

+        void defineSyntax();

+

+    private:

+        enum Opts

+        {

+            COLUMNS,

+            SYSTEM_OBJECTS

+        };

+

+        AsciiTree getDatabaseTree(const QString& database, SchemaResolver& resolver, bool printColumns);

+        AsciiTree getTableTree(const QString& database, const QString& table, SchemaResolver& resolver, bool printColumns);

+        AsciiTree getViewTree(const QString& database, const QString& view, SchemaResolver& resolver);

+        AsciiTree getTreeLeaf(const QString& column);

+

+        static const QString metaNodeNameTemplate;

+};

+

+#endif // CLICOMMANDTREE_H

diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.cpp b/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.cpp
new file mode 100644
index 0000000..ef0f641
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.cpp
@@ -0,0 +1,64 @@
+#include "clicommanduse.h"
+#include "cli.h"
+#include "services/config.h"
+#include "../cli_config.h"
+#include "services/dbmanager.h"
+
+void CliCommandUse::execute()
+{
+    if (syntax.isArgumentSet(DB_NAME))
+    {
+        if (!cli->getCurrentDb())
+        {
+            println(tr("No current database selected."));
+            return;
+        }
+        println(tr("Current database: %1").arg(cli->getCurrentDb()->getName()));
+        return;
+    }
+
+    Db* db = DBLIST->getByName(syntax.getArgument(DB_NAME));
+    if (!db)
+    {
+        println(tr("No such database: %1").arg(syntax.getArgument(DB_NAME)));
+        return;
+    }
+
+    cli->setCurrentDb(db);
+    CFG_CLI.Console.DefaultDatabase.set(db->getName());
+
+    println(tr("Current database: %1").arg(db->getName()));
+}
+
+QString CliCommandUse::shortHelp() const
+{
+    return tr("changes default working database");
+}
+
+QString CliCommandUse::fullHelp() const
+{
+    return tr(
+                "Changes current working database to <name>. If the <name> database is not registered in the application, "
+                "then the error message is printed and no change is made.\n"
+                "\n"
+                "What is current working database?\n"
+                "When you type a SQL query to be executed, it is executed on the default database, which is also known as "
+                "the current working database. Most of database-related commands can also work using default database, if no database was "
+                "provided in their arguments. The current database is always identified by command line prompt. "
+                "The default database is always defined (unless there is no database on the list at all).\n"
+                "\n"
+                "The default database can be selected in various ways:\n"
+                "- using %1 command,\n"
+                "- by passing database file name to the application startup parameters,\n"
+                "- by passing registered database name to the application startup parameters,\n"
+                "- by restoring previously selected default database from saved configuration,\n"
+                "- or when default database was not selected by any of the above, then first database from the registered databases list "
+                "becomes the default one."
+                ).arg(cmdName("use"));
+}
+
+void CliCommandUse::defineSyntax()
+{
+    syntax.setName("use");
+    syntax.addArgument(DB_NAME, tr("name", "CLI command syntax"), false);
+}
diff --git a/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.h b/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.h
new file mode 100644
index 0000000..9a8f280
--- /dev/null
+++ b/SQLiteStudio3/sqlitestudiocli/commands/clicommanduse.h
@@ -0,0 +1,15 @@
+#ifndef CLICOMMANDUSE_H
+#define CLICOMMANDUSE_H
+
+#include "clicommand.h"
+
+class CliCommandUse : public CliCommand
+{
+    public:
+        void execute();
+        QString shortHelp() const;
+        QString fullHelp() const;
+        void defineSyntax();
+};
+
+#endif // CLICOMMANDUSE_H