Added transaction isolation level and access mode

SakiTakamachi · SakiTakamachi · commit 539813d6cab2 · 2023-11-14T21:18:49.000+09:00
diff --git a/ext/pdo_firebird/firebird_driver.c b/ext/pdo_firebird/firebird_driver.c
@@ -28,12 +28,14 @@
 #include "ext/standard/info.h"
 #include "pdo/php_pdo.h"
 #include "pdo/php_pdo_driver.h"
+#include "pdo/php_pdo_error.h"
 #include "php_pdo_firebird.h"
 #include "php_pdo_firebird_int.h"
+#include "firebird_driver_arginfo.h"
 
 static int firebird_alloc_prepare_stmt(pdo_dbh_t*, const zend_string*, XSQLDA*, isc_stmt_handle*, HashTable*);
 static bool firebird_commit_transaction(pdo_dbh_t *dbh, bool retain);
-static bool _firebird_rollback_transaction(pdo_dbh_t *dbh, bool retain);
+static bool firebird_rollback_transaction(pdo_dbh_t *dbh, bool retain);
 
 const char CHR_LETTER = 1;
 const char CHR_DIGIT = 2;
@@ -480,7 +482,7 @@ static void firebird_handle_closer(pdo_dbh_t *dbh) /* {{{ */
 		if (dbh->auto_commit) {
 			firebird_commit_transaction(dbh, false);
 		} else {
-			_firebird_rollback_transaction(dbh, false);
+			firebird_rollback_transaction(dbh, false);
 		}
 	}
 	H->in_manually_txn = 0;
@@ -702,48 +704,31 @@ static zend_string* firebird_handle_quoter(pdo_dbh_t *dbh, const zend_string *un
 static bool firebird_begin_transaction(pdo_dbh_t *dbh) /* {{{ */
 {
 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
-	char tpb[8] = { isc_tpb_version3 }, *ptpb = tpb+1;
-#ifdef abies_0
-	if (dbh->transaction_flags & PDO_TRANS_ISOLATION_LEVEL) {
-		if (dbh->transaction_flags & PDO_TRANS_READ_UNCOMMITTED) {
-			/* this is a poor fit, but it's all we have */
+	char tpb[5] = { isc_tpb_version3 }, *ptpb = tpb + strlen(tpb);
+
+	switch (H->txn_isolation_level) {
+		case PDO_FB_READ_COMMITTED:
 			*ptpb++ = isc_tpb_read_committed;
 			*ptpb++ = isc_tpb_rec_version;
-			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_READ_UNCOMMITTED);
-		} else if (dbh->transaction_flags & PDO_TRANS_READ_COMMITTED) {
-			*ptpb++ = isc_tpb_read_committed;
-			*ptpb++ = isc_tpb_no_rec_version;
-			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_READ_COMMITTED);
-		} else if (dbh->transaction_flags & PDO_TRANS_REPEATABLE_READ) {
-			*ptpb++ = isc_tpb_concurrency;
-			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_REPEATABLE_READ);
-		} else {
+			break;
+
+		case PDO_FB_SERIALIZABLE:
 			*ptpb++ = isc_tpb_consistency;
-			dbh->transaction_flags &= ~(PDO_TRANS_ISOLATION_LEVEL^PDO_TRANS_SERIALIZABLE);
-		}
-	}
+			break;
 
-	if (dbh->transaction_flags & PDO_TRANS_ACCESS_MODE) {
-		if (dbh->transaction_flags & PDO_TRANS_READONLY) {
-			*ptpb++ = isc_tpb_read;
-			dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READONLY);
-		} else {
-			*ptpb++ = isc_tpb_write;
-			dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READWRITE);
-		}
+		case PDO_FB_REPEATABLE_READ:
+		default:
+			*ptpb++ = isc_tpb_concurrency;
+			break;
 	}
 
-	if (dbh->transaction_flags & PDO_TRANS_CONFLICT_RESOLUTION) {
-		if (dbh->transaction_flags & PDO_TRANS_RETRY) {
-			*ptpb++ = isc_tpb_wait;
-			dbh->transaction_flags &= ~(PDO_TRANS_CONFLICT_RESOLUTION^PDO_TRANS_RETRY);
-		} else {
-			*ptpb++ = isc_tpb_nowait;
-			dbh->transaction_flags &= ~(PDO_TRANS_CONFLICT_RESOLUTION^PDO_TRANS_ABORT);
-		}
+	if (H->is_writable_txn) {
+		*ptpb++ = isc_tpb_write;
+	} else {
+		*ptpb++ = isc_tpb_read;
 	}
-#endif
-	if (isc_start_transaction(H->isc_status, &H->tr, 1, &H->db, (unsigned short)(ptpb-tpb), tpb)) {
+
+	if (isc_start_transaction(H->isc_status, &H->tr, 1, &H->db, (unsigned short)(ptpb - tpb), tpb)) {
 		RECORD_ERROR(dbh);
 		return false;
 	}
@@ -804,8 +789,8 @@ static bool firebird_handle_manually_commit(pdo_dbh_t *dbh) /* {{{ */
 }
 /* }}} */
 
-/* _firebird_rollback_transaction */
-static bool _firebird_rollback_transaction(pdo_dbh_t *dbh, bool retain) /* {{{ */
+/* firebird_rollback_transaction */
+static bool firebird_rollback_transaction(pdo_dbh_t *dbh, bool retain) /* {{{ */
 {
 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
 
@@ -830,7 +815,7 @@ static bool firebird_handle_manually_rollback(pdo_dbh_t *dbh) /* {{{ */
 {
 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
 
-	if (!_firebird_rollback_transaction(dbh, dbh->auto_commit)) {
+	if (!firebird_rollback_transaction(dbh, dbh->auto_commit)) {
 		return false;
 	}
 
@@ -884,6 +869,7 @@ static bool firebird_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *
 {
 	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
 	bool bval;
+	zend_long lval;
 
 	switch (attr) {
 		case PDO_ATTR_AUTOCOMMIT:
@@ -964,6 +950,36 @@ static bool firebird_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *
 				zend_string_release_ex(str, 0);
 			}
 			return true;
+
+		case PDO_FB_TRANSACTION_ISOLATION_LEVEL:
+			{
+				if (!pdo_get_long_param(&lval, val)) {
+					return false;
+				}
+				if (H->txn_isolation_level != lval) {
+					if (lval == PDO_FB_READ_COMMITTED ||
+						lval == PDO_FB_REPEATABLE_READ ||
+						lval == PDO_FB_SERIALIZABLE
+					) {
+						if (H->tr && H->in_manually_txn) {
+							H->last_app_error = "Cannot change isolation level while a transaction is already open";
+							return false;
+						}
+						H->txn_isolation_level = lval;
+						if (dbh->auto_commit) {
+							if (H->tr && !firebird_commit_transaction(dbh, false)) {
+								return false;
+							}
+							if (!firebird_begin_transaction(dbh)) {
+								return false;
+							}
+						}
+					} else {
+						return false;
+					}
+				}
+			}
+			return true;
 	}
 	return false;
 }
@@ -1064,6 +1080,71 @@ static void pdo_firebird_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval
 }
 /* }}} */
 
+/* change transaction access mode. writable or readonly */
+static bool change_transaction_access_mode(pdo_dbh_t *dbh, bool writable) /* {{{ */
+{
+	pdo_firebird_db_handle *H = (pdo_firebird_db_handle *)dbh->driver_data;
+
+	if (H->is_writable_txn == writable) {
+		return true;
+	}
+
+	if (H->tr && H->in_manually_txn) {
+		H->last_app_error = "Cannot change access mode while a transaction is already open";
+		PDO_HANDLE_DBH_ERR();
+		return false;
+	}
+	H->is_writable_txn = writable;
+	if (dbh->auto_commit) {
+		if (H->tr && !firebird_commit_transaction(dbh, false)) {
+			return false;
+		}
+		if (!firebird_begin_transaction(dbh)) {
+			return false;
+		}
+	}
+	return true;
+}
+/* }}} */
+
+/* {{{ change transaction mode to writable */
+PHP_METHOD(PDO_Firebird_Ext, fbWritable)
+{
+	pdo_dbh_t *dbh;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	dbh = Z_PDO_DBH_P(ZEND_THIS);
+	PDO_CONSTRUCT_CHECK;
+
+	RETURN_BOOL(change_transaction_access_mode(dbh, true));
+}
+/* }}} */
+
+/* {{{ change transaction mode to readonly */
+PHP_METHOD(PDO_Firebird_Ext, fbReadonly)
+{
+	pdo_dbh_t *dbh;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	dbh = Z_PDO_DBH_P(ZEND_THIS);
+	PDO_CONSTRUCT_CHECK;
+
+	RETURN_BOOL(change_transaction_access_mode(dbh, false));
+}
+/* }}} */
+
+static const zend_function_entry *pdo_firebird_get_driver_methods(pdo_dbh_t *dbh, int kind)
+{
+	switch (kind) {
+		case PDO_DBH_DRIVER_METHOD_KIND_DBH:
+			return class_PDO_Firebird_Ext_methods;
+		default:
+			return NULL;
+	}
+}
+
 /* {{{ firebird_in_manually_transaction */
 static bool firebird_in_manually_transaction(pdo_dbh_t *dbh)
 {
@@ -1085,7 +1166,7 @@ static const struct pdo_dbh_methods firebird_methods = { /* {{{ */
 	pdo_firebird_fetch_error_func,
 	firebird_handle_get_attribute,
 	NULL, /* check_liveness */
-	NULL, /* get driver methods */
+	pdo_firebird_get_driver_methods,
 	NULL, /* request shutdown */
 	firebird_in_manually_transaction,
 	NULL /* get gc */
@@ -1169,6 +1250,7 @@ static int pdo_firebird_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /*
 	}
 
 	H->in_manually_txn = 0;
+	H->is_writable_txn = 1;
 	if (dbh->auto_commit && !H->tr) {
 		ret = firebird_begin_transaction(dbh);
 	}
diff --git a/ext/pdo_firebird/firebird_driver.stub.php b/ext/pdo_firebird/firebird_driver.stub.php
@@ -0,0 +1,15 @@
+<?php
+
+/** @generate-function-entries */
+
+/**
+ * These are extension methods for PDO. This is not a real class.
+ * @undocumentable
+ */
+class PDO_Firebird_Ext {
+    /** @tentative-return-type */
+    public function fbWritable(): bool {}
+
+    /** @tentative-return-type */
+    public function fbReadonly(): bool {}
+}
diff --git a/ext/pdo_firebird/firebird_driver_arginfo.h b/ext/pdo_firebird/firebird_driver_arginfo.h
diff --git a/ext/pdo_firebird/pdo_firebird.c b/ext/pdo_firebird/pdo_firebird.c
@@ -57,6 +57,10 @@ PHP_MINIT_FUNCTION(pdo_firebird) /* {{{ */
 	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_DATE_FORMAT", (zend_long) PDO_FB_ATTR_DATE_FORMAT);
 	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_TIME_FORMAT", (zend_long) PDO_FB_ATTR_TIME_FORMAT);
 	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_TIMESTAMP_FORMAT", (zend_long) PDO_FB_ATTR_TIMESTAMP_FORMAT);
+	REGISTER_PDO_CLASS_CONST_LONG("FB_TRANSACTION_ISOLATION_LEVEL", (zend_long) PDO_FB_TRANSACTION_ISOLATION_LEVEL);
+	REGISTER_PDO_CLASS_CONST_LONG("FB_READ_COMMITTED", (zend_long) PDO_FB_READ_COMMITTED);
+	REGISTER_PDO_CLASS_CONST_LONG("FB_REPEATABLE_READ", (zend_long) PDO_FB_REPEATABLE_READ);
+	REGISTER_PDO_CLASS_CONST_LONG("FB_SERIALIZABLE", (zend_long) PDO_FB_SERIALIZABLE);
 
 	if (FAILURE == php_pdo_register_driver(&pdo_firebird_driver)) {
 		return FAILURE;
diff --git a/ext/pdo_firebird/php_pdo_firebird_int.h b/ext/pdo_firebird/php_pdo_firebird_int.h
@@ -70,6 +70,7 @@ typedef struct {
 	/* the transaction handle */
 	isc_tr_handle tr;
 	bool in_manually_txn:1;
+	bool is_writable_txn:1;
 
 	/* the last error that didn't come from the API */
 	char const *last_app_error;
@@ -86,6 +87,8 @@ typedef struct {
 
 	unsigned _reserved:29;
 
+	/* transaction isolation level */
+	zend_ulong txn_isolation_level;
 } pdo_firebird_db_handle;
 
 
@@ -132,6 +135,12 @@ enum {
 	PDO_FB_ATTR_DATE_FORMAT = PDO_ATTR_DRIVER_SPECIFIC,
 	PDO_FB_ATTR_TIME_FORMAT,
 	PDO_FB_ATTR_TIMESTAMP_FORMAT,
+
+	/* transaction isolation level */
+	PDO_FB_TRANSACTION_ISOLATION_LEVEL,
+	PDO_FB_READ_COMMITTED,
+	PDO_FB_REPEATABLE_READ,
+	PDO_FB_SERIALIZABLE,
 };
 
 #endif	/* PHP_PDO_FIREBIRD_INT_H */
