Added transaction isolation level and access mode

Author: SakiTakamachi

ext/pdo_firebird/firebird_driver.c

@@ -28,10 +28,13 @@
 #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_change_transaction_access_mode(pdo_dbh_t *dbh, bool writable);
 
 const char CHR_LETTER = 1;
 const char CHR_DIGIT = 2;
@@ -700,48 +703,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;
 	}
@@ -882,6 +868,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:
@@ -962,6 +949,44 @@ 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;
+
+		case PDO_FB_WRITABLE_TRANSACTION:
+			{
+				if (!pdo_get_bool_param(&bval, val)) {
+					return false;
+				}
+				return firebird_change_transaction_access_mode(dbh, bval);
+			}
 	}
 	return false;
 }
@@ -1062,6 +1087,70 @@ 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 firebird_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";
+		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;
+}
+
+/* fbWritable or fbReadonly */
+static void firebird_fb_access_mode(INTERNAL_FUNCTION_PARAMETERS, bool writable) /* {{{ */
+{
+	pdo_dbh_t *dbh;
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	dbh = Z_PDO_DBH_P(ZEND_THIS);
+	PDO_CONSTRUCT_CHECK;
+
+	RETURN_BOOL(firebird_change_transaction_access_mode(dbh, writable));
+}
+/* }}} */
+
+/* {{{ change transaction mode to writable */
+PHP_METHOD(PDO_Firebird_Ext, fbWritable)
+{
+	firebird_fb_access_mode(INTERNAL_FUNCTION_PARAM_PASSTHRU, true);
+}
+/* }}} */
+
+/* {{{ change transaction mode to readonly */
+PHP_METHOD(PDO_Firebird_Ext, fbReadonly)
+{
+	firebird_fb_access_mode(INTERNAL_FUNCTION_PARAM_PASSTHRU, 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)
 {
@@ -1083,7 +1172,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 */
@@ -1116,6 +1205,20 @@ static int pdo_firebird_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /*
 		dbh->password = pestrdup(vars[5].optval, dbh->is_persistent);
 	}
 
+	H->in_manually_txn = 0;
+	if (driver_options) {
+		H->is_writable_txn = pdo_attr_lval(driver_options, PDO_FB_WRITABLE_TRANSACTION, 1);
+		zend_long txn_isolation_level = pdo_attr_lval(driver_options, PDO_FB_TRANSACTION_ISOLATION_LEVEL, PDO_FB_REPEATABLE_READ);
+		if (txn_isolation_level == PDO_FB_READ_COMMITTED ||
+			txn_isolation_level == PDO_FB_REPEATABLE_READ ||
+			txn_isolation_level == PDO_FB_SERIALIZABLE
+		) {
+			H->txn_isolation_level = txn_isolation_level;
+		} else {
+			H->txn_isolation_level = PDO_FB_REPEATABLE_READ;
+		}
+	}
+
 	do {
 		static char const dpb_flags[] = {
 			isc_dpb_user_name, isc_dpb_password, isc_dpb_lc_ctype, isc_dpb_sql_role_name };
@@ -1166,7 +1269,6 @@ static int pdo_firebird_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /*
 				"HY000", H->isc_status[1], errmsg);
 	}
 
-	H->in_manually_txn = 0;
 	if (dbh->auto_commit && !H->tr) {
 		ret = _firebird_begin_transaction(dbh);
 	}

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 {}
+}

ext/pdo_firebird/firebird_driver_arginfo.h

@@ -57,6 +57,11 @@ 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);
+	REGISTER_PDO_CLASS_CONST_LONG("FB_WRITABLE_TRANSACTION", (zend_long) PDO_FB_WRITABLE_TRANSACTION);
 
 	if (FAILURE == php_pdo_register_driver(&pdo_firebird_driver)) {
 		return FAILURE;

ext/pdo_firebird/pdo_firebird.c

@@ -60,10 +60,10 @@ typedef void (*info_func_t)(char*);
 #endif
 
 extern bool _firebird_commit_transaction(pdo_dbh_t *dbh, bool retain);
-#define firebird_commit_transaction(d, r)	_firebird_commit_transaction(d, r)
+#define firebird_commit_transaction(d,r) _firebird_commit_transaction(d, r)
 
 extern bool _firebird_rollback_transaction(pdo_dbh_t *dbh, bool retain);
-#define firebird_rollback_transaction(d, r)	_firebird_rollback_transaction(d, r)
+#define firebird_rollback_transaction(d,r) _firebird_rollback_transaction(d, r)
 
 typedef struct {
 
@@ -76,6 +76,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;
@@ -92,6 +93,8 @@ typedef struct {
 
 	unsigned _reserved:29;
 
+	/* transaction isolation level */
+	zend_ulong txn_isolation_level;
 } pdo_firebird_db_handle;
 
 
@@ -138,6 +141,15 @@ 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,
+
+	/** transaction access mode */
+	PDO_FB_WRITABLE_TRANSACTION,
 };
 
 #endif	/* PHP_PDO_FIREBIRD_INT_H */