ODBC changes

Author: SingingBush

.github/workflows/dub.yml

@@ -22,32 +22,6 @@ jobs:
         os: [ ubuntu-latest, windows-latest ]
         compiler:
           - dmd-latest
-          - ldc-latest
-          - dmd-2.109.1 # (released in 2024)
-          - dmd-2.108.1 # (released in 2024)
-          - dmd-2.107.1 # (released in 2024)
-          - dmd-2.106.1 # (released in 2024)
-          - dmd-2.105.3 # (released in 2023) 
-          - dmd-2.104.2 # (released in 2023)
-          - dmd-2.103.1 # (released in 2023)
-          - dmd-2.102.2 # (released in 2023)
-          - dmd-2.101.2 # (released in 2023)
-          - dmd-2.100.2 # (released in 2022) ## GDC 12 can support 2.100
-          - dmd-2.099.1 # (released in 2022)
-          - dmd-2.098.1 # (released in 2021) ## Has issue re: phobos/std/variant.d
-          - dmd-2.097.2 # (released in 2021)
-          - ldc-1.33.0 # eq to dmd v2.103.1
-          - ldc-1.32.2 # eq to dmd v2.102.2
-          - ldc-1.28.1 # eq to dmd v2.098.1
-          - ldc-1.27.1 # eq to dmd v2.097.2
-        include:
-          ## LDC supports Apple silicon
-          - { os: macos-latest, compiler: ldc-latest }
-          ## macos-13 is the latest Mac runner with Intel cpu
-          - { os: macos-13, compiler: dmd-latest }
-          - { os: macos-13, compiler: ldc-latest }
-          - { os: macos-13, compiler: dmd-2.108.1 }
-          - { os: macos-13, compiler: ldc-1.32.2 }
         exclude:
           - { os: windows-latest, compiler: dmd-2.098.1 }
           - { os: windows-latest, compiler: dmd-2.097.2 }

source/ddbc/core.d

@@ -1,18 +1,18 @@
 /**
- * DDBC - D DataBase Connector - abstraction layer for RDBMS access, with interface similar to JDBC. 
- * 
+ * DDBC - D DataBase Connector - abstraction layer for RDBMS access, with interface similar to JDBC.
+ *
  * Source file ddbc/core.d.
  *
  * DDBC library attempts to provide implementation independent interface to different databases.
- * 
+ *
  * Set of supported RDBMSs can be extended by writing Drivers for particular DBs.
  * Currently it only includes MySQL Driver which uses patched version of MYSQLN (native D implementation of MySQL connector, written by Steve Teale)
- * 
+ *
  * JDBC documentation can be found here:
  * $(LINK http://docs.oracle.com/javase/1.5.0/docs/api/java/sql/package-summary.html)$(BR)
  *
  * Limitations of current version: readonly unidirectional resultset, completely fetched into memory.
- * 
+ *
  * Its primary objects are:
  * $(UL
  *    $(LI Driver: $(UL $(LI Implements interface to particular RDBMS, used to create connections)))
@@ -134,64 +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
- */
+
+/**
+ * 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();
@@ -214,21 +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);
+
+    /**
+     * 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 {
@@ -349,18 +349,19 @@ interface DataSetWriter {
 
 interface ResultSet : DataSetReader {
 	void close();
+    /// Will return true if the ResultSet is pointing at the first row
 	bool first();
 	bool isFirst();
 	bool isLast();
 	bool next();
 
-	//Retrieves the number, types and properties of this ResultSet object's columns
+    /// Retrieves the number, types and properties of this ResultSet object's columns
 	ResultSetMetaData getMetaData();
-	//Retrieves the Statement object that produced this ResultSet object.
+    /// Retrieves the Statement object that produced this ResultSet object.
 	Statement getStatement();
-	//Retrieves the current row number
+    /// Retrieves the current row number
 	int getRow();
-	//Retrieves the fetch size for this ResultSet object.
+    /// Retrieves the fetch size for this ResultSet object.
 	deprecated("Marked for removal as Cannot be used by all supported drivers. See Github issue #85")
 	ulong getFetchSize();
 
@@ -436,7 +437,7 @@ interface Statement : DialectAware {
 	void close();
 }
 
-/// An object that represents a precompiled SQL statement. 
+/// An object that represents a precompiled SQL statement.
 interface PreparedStatement : Statement, DataSetWriter {
 	/// Executes the SQL statement in this PreparedStatement object, which must be an SQL INSERT, UPDATE or DELETE statement; or an SQL statement that returns nothing, such as a DDL statement.
 	int executeUpdate();
@@ -495,7 +496,7 @@ string makeDDBCUrl(string driverName, string[string] params) {
 }
 
 /// Helper function to make url in form driverName://host:port/dbname?param1=value1,param2=value2
-string makeDDBCUrl(string driverName, string host = null, int port = 0, 
+string makeDDBCUrl(string driverName, string host = null, int port = 0,
 							string dbName = null, string[string] params = null) {
 	import std.algorithm.searching : canFind;
 	enforce(canFind(["sqlite", "postgresql", "mysql", "sqlserver", "oracle", "odbc"], driverName), "driver must be one of sqlite|postgresql|mysql|sqlserver|oracle|odbc");
@@ -593,4 +594,4 @@ private unittest {
 
 	string url = makeDDBCUrl("odbc", params);
 	assert(url == "odbc://?dsn=myDSN", "ODBC URL is not correct: "~url);
-}
+}