The argument can be passed several times and all the CSV files are added to
the Import CSV dialog. When no database to open is passed in the command line,
the CSV files are imported into a new in-memory database, which could later
be saved as a file, if desired.
This option could be used as basis for adding a file association to CSV files
for DB4S.
See issue #2589.
- Command line arguments are not given to translations, only descriptions
and placeholders.
- Formatting is done programmatically, so developers and translators don't
have to adjust that themselves.
This will affect translations but will be better in the long run.
This fixes some severe bugs in the Browse Data tab with editing and
deleting rows in WITHOUT ROWID tables.
These were introduced in 02db68107a.
See issue #2582.
This improves the performance of executing multiple modifying SQL
statements, like INSERTs or UPDATEs, in the Execute SQL tab a lot by
not updating the plot dock after every single statement.
See issue #2572.
This commit does a lot of refactoring. But most noticeably it changes
two things:
1) Instead of saving all objects (tables, views, indices, triggers) of a
schema in a common map, we now store tables/views, indices and
triggers in three separate maps. This has a number of benefits:
- It resembles more closely how SQLite stores its data internally and
therefore achieves greater compatability e.g. for databases with a
view and a trigger with the same name.
- It reduces the need for runtime polymorphism. This makes the code
run a bit faster.
- By working with explicit types more often more error checking can
be done at compile time, making the code less error prone.
- The code becomes a lot clearer to read.
2) By making View inherit form Table, views are now a sort of tables.
This has the following benefits:
- This is a again how SQLite stores views internally which again
should increase compatibility a bit.
- We mostly treat views and tables the same anyway and with these
changes we can unify the code for them even more.
For the same reasons we changed the ORDER BY part of query objects to
use their names instead of their indexes to address columns, this commit
changes the handling of the WHERE part of a query to use column names
too.
This changes the structures for representing SELECT statements to save
the names of sorted column instead of their indexes. This change has
several benefits:
- It prepares the Query class to store actual real-world SELECT
statements in the future.
- It prepares us to sort by expressions instead of just columns.
- This way we do not need an extra list of column names to generate the
ORDER BY part of the SELECT statement when building it.
This simplifies the usage and the implementation of the SqliteTableModel
a bit by making the two operating modes it supports (manual query and
interactive query) more obvious in its public interface as well as
simplifying the control flow in the private implementation.
Change some function parameters which are named like "dont..." to make a
positive statement. This should hopefully avoid some confisions with
double negation.
The feature is implemented using the SQLite backup API.
https://sqlite.org/backup.html
This allows saving in-memory databases and saving database files to another
file name.
When opening a database and clicking on a table in the Database
Structure tab, the buttons for modifying or deleting the table were
still disabled. Only on the second click activated the buttons
correctly.
See issue #2528.
This fixes two issues when executing SQL statements:
- When reusing a model object the row count was not reset. This meant
that when the second query returned less rows than the first a bunch
of "loading..." cells were still visible.
- The workaround for making sure the plot dock was only updated when the
data was ready (instead of just the row count), now that the data is
ready before the row count, would stop the worker thread from ever
finishing.
See issue #2535.
This partially reverts 89587a7d67 to fix
some issues it introduced. Using the knowledge we gained in the further
optimisation process, this commit now gets us the best of both worlds:
good performance when executing complex queries as well as a more
straightforward way to deal with the multithreaded nature of data
loading.
See issue #2537.
In MainWindow::closeEvent() now it calls Settings::sync() to call
QSettings->sync(). Qt documentation
(https://doc.qt.io/qt-5/qsettings.html#sync) says:
"This function is called automatically from QSettings's destructor and
by the event loop at regular intervals, so you normally don't need to
call it yourself."
On my Linux machine QSettings was not syncing to the
~/.config/sqlitebrowser/sqlitebrowser.conf (e.g. if I was doing View ->
Window Layout -> Simplify Window Layout and then close quickly was not
saved). Other settings recently changed before exiting would have been
the same.
Note that Settings is fully static so this seems to be an easy fix.
Previously RemoteDock was not resizeable too small due to all the
widgets (which have minimum size)
Now with QScrollArea a vertical scroll bar appears if needed allowing
MainWindow too be smaller
This updates the qmake and cmake files to enable C++14 support in the
compiler. It also simplifies a function by using a new function
introduced in C++14.
This fixes a remaining issue which was introduced in the series of
commits made for improving the performance of running SELECT statements
in the Execute SQL tab. The problem here was that rerunning a query did
not show any results in the view.
See issue #2165.
This speeds up executing SELECT statements in the Execute SQL tab even
further. Before this the statement was executed twice: once to determine
whether it returns any data and another time to actually get the data.
This is still done after this commit, however the process to determine
whether a statement returns any data is optimised in a way which almost
reduces the runtime of this step to zero.
See issue #2165.
This further improves the performance of SELECT statements by not
triggering the row count determiniation if it is not needed. So for
queries which return less rows than the configured prefetch block size
we save an extra query. Because this requires querying the data first
and the row count second (before this the order was reversed) the data
also appears faster in the UI.
This commit also fixes another issue which was introduced in commit
89587a7d67: When setting a filter which
made the query not return any data, the column names and the filter row
became invisible. Because of that it was also impossible to change the
filter again.
This improves the performance of running SQL queries in the
SqliteTableModel class by avoiding an extra query for figuring out the
column names and data types of the returned data.
See issue #2165.
