Add Support for Transactions (#121) autocommit, commit, and rollback, and transaction isolation

* Added support for autocommit, commit, and rollback, and transaction isolation level for Postgresql, MySQL, ODBC, and Sqlite. Added tests for autocommit.

* Add tests for set/get TransactionIsolation.

* Remove commented-out block of code.

* Remove debug writeln statements and split main test into several files.

Author: vnayar

.editorconfig

@@ -0,0 +1,17 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+
+[*.{c,h,d,di,dd,json}]
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.{yml}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false

CONTRIBUTING.md

@@ -2,11 +2,17 @@ DDBC aims to support a range of compiler versions across from dmd 2.097 and abov
 
 ## Tests
 
-To help with testing there is a *docker-compose.yml* file in the root of the project so that multiple databases can be run locally for testing. 
+To help with testing there is a *docker-compose.yml* file in the root of the project so that multiple databases can be run locally for testing.
 
 When making changes to DDBC please ensure that unit tests (test not requiring a working database) remain in the project source and any integration tests (those running against a local database) are placed the test project (under `./test/ddbctest/`).
 
-unit tests can br run in the usual way with `dub test` and integration tests are run with `dub run --config=test`.
+Unit tests can be run in the usual way with `dub test` and integration tests are run with `dub run --config=test`.
+
+To summarize, testing should be done as follows:
+1. `dub test` - Runs unit tests.
+2. `docker-compose up` - Creates various locally running databases in containers.
+3. `dub run --config=test` - Runs integration tests aganist the local databases.
+4. `docker-compose down` - Destroys the locally created databases.
 
 ## Requirements for developing
 

source/ddbc/common.d

@@ -114,6 +114,10 @@ class ConnectionWrapper : Connection {
 	override bool getAutoCommit() { return base.getAutoCommit(); }
 	override void setAutoCommit(bool autoCommit) { base.setAutoCommit(autoCommit); }
 	override void setCatalog(string catalog) { base.setCatalog(catalog); }
+    override TransactionIsolation getTransactionIsolation() { return base.getTransactionIsolation(); }
+    override void setTransactionIsolation(TransactionIsolation level) {
+        base.setTransactionIsolation(level);
+    }
 }
 
 // remove array item inplace

source/ddbc/core.d

@@ -134,6 +134,64 @@ enum SqlType {
 	VARCHAR,
 }
 
+
+/**
+ * The level of isolation between transactions. Various isolation levels provide tradeoffs between
+ * performance, reproducibility, and interactions with other simultaneous transactions.
+ *
+ * The default transaction isolation level depends on the DB driver. For example:
+ * - Postgresql: Defaults to READ_COMMITTED
+ * - MySQL: Defaults to REPEATABLE_READ
+ * - SQLite: Defaults to SERIALIZABLE
+ *
+ * Generally, `SELECT` statements do see the effects of previous `UPDATE` statements within the same
+ * transaction, despite the fact that they are not yet committed.  However, there can be differences
+ * between database implementations depending on the transaction isolation level.
+ */
+enum TransactionIsolation {
+  /**
+   * Transactions are not supported at all, thus there is no isolation.
+   */
+  NONE,
+
+  /**
+   * Statements can read rows that have been modified by other transactions but are not yet
+   * committed. High parallelism, but risks dirty reads, non-repeatable reads, etc.
+   */
+  READ_UNCOMMITTED,
+
+  /**
+   * Statements cannot read data that has been modified by other transactions but not yet
+   * committed. However, data can be changed when other transactions are commited between statements
+   * of a transaction resulting in non-repeatable reads or phantom data.
+   */
+  READ_COMMITTED,
+
+  /**
+   * Shared locks are used to prevent modification of data read by transactions, preventing dirty
+   * reads and non-repeatable reads. However, new data can be inserted, causing transactions to
+   * potentially behave differently if the transaction is retried, i.e. "phantom reads".
+   */
+  REPEATABLE_READ,
+
+  /**
+   * Locks are used to make sure transactions using the same data cannot run simultaneously. This
+   * prevents dirty reads, non-repeatable reads, and phantom reads. However, this transaction
+   * isolation level has the worst performance.
+   */
+  SERIALIZABLE,
+}
+
+/**
+ * A connection represents a session with a specific database. Within the context of a Connection,
+ * SQL statements are executed and results are returned.
+ *
+ * Note: By default the Connection automatically commits changes after executing each statement. If
+ * auto commit has been disabled, an explicit commit must be done or database changes will not be
+ * saved.
+ *
+ * See_Also: https://docs.oracle.com/cd/E13222_01/wls/docs45/classdocs/java.sql.Connection.html
+ */
 interface Connection : DialectAware {
 	/// Releases this Connection object's database and JDBC resources immediately instead of waiting for them to be automatically released.
 	void close();
@@ -156,6 +214,21 @@ interface Connection : DialectAware {
 	Statement createStatement();
 	/// Creates a PreparedStatement object for sending parameterized SQL statements to the database.
 	PreparedStatement prepareStatement(string query);
+
+    /**
+     * Returns the currently active transaction isolation level used by the DB connection.
+     */
+    TransactionIsolation getTransactionIsolation();
+
+    /**
+     * Attempt to change the Transaction Isolation Level used for transactions, which controls how
+     * simultaneous transactions will interact with each other. In general, lower isolation levels
+     * require fewer locks and have better performanc, but also have fewer guarantees for
+     * consistency.
+     *
+     * Note: setTransactionIsolation cannot be called while in the middle of a transaction.
+     */
+    void setTransactionIsolation(TransactionIsolation level);
 }
 
 interface ResultSetMetaData {
@@ -520,4 +593,4 @@ private unittest {
 
 	string url = makeDDBCUrl("odbc", params);
 	assert(url == "odbc://?dsn=myDSN", "ODBC URL is not correct: "~url);
-}
+}

source/ddbc/drivers/mysqlddbc.d

@@ -300,6 +300,67 @@ public:
             throw new SQLException(e);
         }
     }
+
+    /// See_Also: https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_transaction_isolation
+    override TransactionIsolation getTransactionIsolation() {
+        checkClosed();
+        lock();
+        scope(exit) unlock();
+
+        try {
+            Statement stmt = createStatement();
+            scope(exit) stmt.close();
+            ddbc.core.ResultSet resultSet = stmt.executeQuery("SELECT @@transaction_isolation");
+            if (resultSet.next()) {
+                switch (resultSet.getString(1)) {
+                    case "READ-UNCOMMITTED":
+                        return TransactionIsolation.READ_UNCOMMITTED;
+                    case "READ-COMMITTED":
+                        return TransactionIsolation.READ_COMMITTED;
+                    case "SERIALIZABLE":
+                        return TransactionIsolation.SERIALIZABLE;
+                    case "REPEATABLE-READ":
+                    default:  // MySQL default
+                        return TransactionIsolation.REPEATABLE_READ;
+                }
+            } else {
+                return TransactionIsolation.REPEATABLE_READ;  // MySQL default
+            }
+        } catch (Throwable e) {
+            throw new SQLException(e);
+        }
+    }
+
+    /// See_Also: https://dev.mysql.com/doc/refman/8.0/en/set-transaction.html
+    override void setTransactionIsolation(TransactionIsolation level) {
+        checkClosed();
+        lock();
+        scope(exit) unlock();
+
+        try {
+            Statement stmt = createStatement();
+            // See: https://dev.mysql.com/doc/refman/8.0/en/set-transaction.html
+            string query = "SET SESSION TRANSACTION ISOLATION LEVEL ";
+            switch (level) {
+                case TransactionIsolation.READ_UNCOMMITTED:
+                    query ~= "READ UNCOMMITTED";
+                    break;
+                case TransactionIsolation.READ_COMMITTED:
+                    query ~= "READ COMMITTED";
+                    break;
+                case TransactionIsolation.SERIALIZABLE:
+                    query ~= "SERIALIZABLE";
+                    break;
+                case TransactionIsolation.REPEATABLE_READ:
+                default:
+                    query ~= "REPEATABLE READ";
+                    break;
+            }
+            stmt.executeUpdate(query);
+        } catch (Throwable e) {
+            throw new SQLException(e);
+        }
+    }
 }
 
 class MySQLStatement : Statement {

source/ddbc/drivers/odbcddbc.d

@@ -558,18 +558,62 @@ version (USE_ODBC)
         override void setAutoCommit(bool autoCommit)
         {
             checkClosed();
-            if (this.autocommit != autocommit)
+            if (this.autocommit != autoCommit)
             {
                 lock();
                 scope (exit)
                     unlock();
 
                 uint ac = autoCommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
 
-                checkdbc!SQLSetConnectAttr(conn, SQL_ATTR_AUTOCOMMIT, &ac, SQL_IS_UINTEGER);
+                checkdbc!SQLSetConnectAttr(conn, SQL_ATTR_AUTOCOMMIT, cast(SQLPOINTER) ac, 0);
+                this.autocommit = autoCommit;
+            }
+        }
 
-                this.autocommit = autocommit;
+        override TransactionIsolation getTransactionIsolation() {
+            checkClosed();
+            lock();
+            scope(exit) unlock;
+            // See https://odbc.dpldocs.info/v1.0.0/source/odbc.sql.d.html#L571
+            long level;
+            checkdbc!SQLGetConnectAttr(conn, SQL_ATTR_TXN_ISOLATION, &level, 0, null);
+            switch (level) {
+                case SQL_TXN_READ_UNCOMMITTED:
+                    return TransactionIsolation.READ_UNCOMMITTED;
+                case SQL_TXN_READ_COMMITTED:
+                    return TransactionIsolation.READ_COMMITTED;
+                case SQL_TXN_REPEATABLE_READ:
+                    return TransactionIsolation.REPEATABLE_READ;
+                case SQL_TXN_SERIALIZABLE:
+                    return TransactionIsolation.SERIALIZABLE;
+                default:
+                    return TransactionIsolation.NONE;
+            }
+        }
+
+        override void setTransactionIsolation(TransactionIsolation level) {
+            checkClosed();
+            lock();
+            scope(exit) unlock();
+
+            uint txnLevel;
+            switch (level) {
+                case TransactionIsolation.READ_UNCOMMITTED:
+                    txnLevel = SQL_TXN_READ_UNCOMMITTED;
+                    break;
+                case TransactionIsolation.READ_COMMITTED:
+                default:
+                    txnLevel = SQL_TXN_READ_COMMITTED;
+                    break;
+                case TransactionIsolation.REPEATABLE_READ:
+                    txnLevel = SQL_TXN_REPEATABLE_READ;
+                    break;
+                case TransactionIsolation.SERIALIZABLE:
+                    txnLevel = SQL_TXN_SERIALIZABLE;
+                    break;
             }
+            checkdbc!SQLSetConnectAttr(conn, SQL_ATTR_TXN_ISOLATION, cast(SQLPOINTER) txnLevel, 0);
         }
     }
 

source/ddbc/drivers/pgsqlddbc.d

@@ -49,6 +49,8 @@ version(USE_PGSQL) {
     //import ddbc.drivers.pgsql;
     import ddbc.drivers.utils;
 
+    // Postgresql Object ID types, which can be checked for query result columns.
+    // See: https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
     const int BOOLOID = 16;
     const int BYTEAOID = 17;
     const int CHAROID = 18;
@@ -336,6 +338,9 @@ version(USE_PGSQL) {
     		Statement stmt = createStatement();
     		scope(exit) stmt.close();
     		stmt.executeUpdate("COMMIT");
+            if (!autocommit) {
+              stmt.executeUpdate("BEGIN");
+            }
     	}
 
     	override Statement createStatement() {
@@ -393,6 +398,9 @@ version(USE_PGSQL) {
     		Statement stmt = createStatement();
     		scope(exit) stmt.close();
     		stmt.executeUpdate("ROLLBACK");
+            if (!autocommit) {
+              stmt.executeUpdate("BEGIN");
+            }
     	}
     	override bool getAutoCommit() {
     		return autocommit;
@@ -404,10 +412,80 @@ version(USE_PGSQL) {
     		lock();
     		scope(exit) unlock();
 
-            autocommit = true;
-
-            //assert(0, "AUTOCOMMIT is no longer supported.");
+            try {
+                Statement stmt = createStatement();
+                scope(exit) stmt.close();
+                if (autoCommit) {
+                  // If switching on autocommit, commit any ongoing transaction.
+                  stmt.executeUpdate("COMMIT");
+                } else {
+                  // If switching off autocommit, start a transaction.
+                  stmt.executeUpdate("BEGIN");
+                }
+                this.autocommit = autoCommit;
+            } catch (Throwable e) {
+                throw new SQLException(e);
+            }
     	}
+
+        override TransactionIsolation getTransactionIsolation() {
+            checkClosed();
+            lock();
+            scope(exit) unlock();
+
+            try {
+                Statement stmt = createStatement();
+                scope(exit) stmt.close();
+                ddbc.core.ResultSet resultSet = stmt.executeQuery("SHOW TRANSACTION ISOLATION LEVEL");
+                if (resultSet.next()) {
+                    switch (resultSet.getString(1)) {
+                        case "read uncommitted":
+                            return TransactionIsolation.READ_UNCOMMITTED;
+                        case "repeatable read":
+                            return TransactionIsolation.REPEATABLE_READ;
+                        case "serializable":
+                            return TransactionIsolation.SERIALIZABLE;
+                        case "read committed":
+                        default:  // Postgresql default
+                            return TransactionIsolation.READ_COMMITTED;
+                    }
+                } else {
+                    return TransactionIsolation.READ_COMMITTED;  // Postgresql default
+                }
+            } catch (Throwable e) {
+                throw new SQLException(e);
+            }
+        }
+
+        override void setTransactionIsolation(TransactionIsolation level) {
+            checkClosed();
+            lock();
+            scope(exit) unlock();
+
+            try {
+                Statement stmt = createStatement();
+                // See: https://www.postgresql.org/docs/current/sql-set-transaction.html
+                string query = "SET TRANSACTION ISOLATION LEVEL ";
+                switch (level) {
+                    case TransactionIsolation.READ_UNCOMMITTED:
+                        query ~= "READ UNCOMMITTED";
+                        break;
+                    case TransactionIsolation.REPEATABLE_READ:
+                        query ~= "REPEATABLE READ";
+                        break;
+                    case TransactionIsolation.SERIALIZABLE:
+                        query ~= "SERIALIZABLE";
+                        break;
+                    case TransactionIsolation.READ_COMMITTED:
+                    default:
+                        query ~= "READ COMMITTED";
+                        break;
+                }
+                stmt.executeUpdate(query);
+            } catch (Throwable e) {
+                throw new SQLException(e);
+            }
+        }
     }
 
     class PGSQLStatement : Statement {