This code manages a SQLite Database Connection

Few remarks

1. Try to make your class reusable. For example it cannot be used in web or console application, because it has reference to namespace System.Windows.Forms. Delete it, delete MessageBox.Show(e.Message); and let client of your library decide itself how to handle exceptions.
2. There are a lot of general .Net name convention violations ... Here for example createSchema. Use CreateSchema instead.
3. I would make your class more lazy :). I mean i would not get all data from database in constructor but only when Tasks method will be called.

First of all, you shouldn't use comments unless you're publishing this as a library or it's very hard to represent what function and classes do by its name.

CreateDatabase() or OpenDatabase() it's pretty straightfoward it does what its name says so a comment it isn't really useful, unless you have many variations of the same function.

Instead of leaving the connection open you could do this when executing queries:

 using (MySqlConnection con = new MySqlConnection(ConnectionString))
 {
   using(MysqlCommand cmd = new MySqlCommand(Command, con);   
   {
     //Add parameters and execute
   }
 }

Besides this I can't see anythin "wrong".

You don't need to create the database file if it doesn't exist, the SQLite driver will take care of it; to ensure your table does not exist on creation, you can just add IF NOT EXISTS to the query.

I would also close the connection every time, this has already been covered by other answers. In addition I would make the class stateless as it doesn't need a state if we open/close the connection every time (Being stateless brings a lot of other advantages).

I would also remove any logic from the constructor, to do this you will need a state or you will have to check on every command unfortunately so I left it to you.

Here is my 0.02:

internal class Timesheet
{
    private const string SelectTaskQuery = "SELECT id, description, begindate, enddate, status FROM task";

    private readonly string _filePath;

    public Timesheet(string filePath)
    {
        _filePath = filePath;

        InitializeDb();
    }

    private DataTable Tasks() => ExecuteWithConnection(Tasks);

    private void InitializeDb() => ExecuteWithConnection(connection =>
    {
        using (var command = connection.CreateCommand())
            CreateSchemaIfNotExists(command);
    });

    private SQLiteConnection GetConnection() => new SQLiteConnection("Data Source=" + _filePath + ";Version=3;");

    private void ExecuteWithConnection(Action<SQLiteConnection> action)
    {
        using (var connection = GetConnection())
        {
            connection.Open();

            action(connection);
        }
    }

    private T ExecuteWithConnection<T>(Func<SQLiteConnection, T> action)
    {
        using (var connection = GetConnection())
            return action(connection);
    }

    private static DataTable Tasks(SQLiteConnection connection)
    {
        var adapter = new SQLiteDataAdapter(SelectTaskQuery, connection);

        var datatable = new DataTable();

        adapter.Fill(datatable);

        return datatable;
    }

    public void Update(DataTable dataTable)
    {
        ExecuteWithConnection(connection =>
        {
            var adapter = new SQLiteDataAdapter(SelectTaskQuery, connection);

            var builder = new SQLiteCommandBuilder(adapter);

            adapter.UpdateCommand = builder.GetUpdateCommand();

            adapter.Update(dataTable);
        });
    }

    private static void CreateSchemaIfNotExists(IDbCommand command)
    {
        const string query = "CREATE TABLE IF NOT EXISTS task (id INTEGER PRIMARY KEY AUTOINCREMENT, description TEXT, begindate TEXT, enddate TEXT, status INTEGER default 0)";

        command.CommandText = query;

        command.ExecuteNonQuery();
    }
}

I would also add a small ORM like Dapper and add statically typed entities for insert/update.

Just my 2 cents worth.

I would create a separate class to handle all interactions wit SQL. Preferably a singleton class so I can reuse it. From there you can handle updates by something like passing in list of columns and the values you would like to update, also including the table. It is pretty flexible on how you want to implement it.

I normally just try to apply the rule of re-usability and scalability, also with KISS (keep it simple stupid) lastly DRY (Don't repeat yourself).