dbobj3 0.8.0__tar.gz → 0.9.3__tar.gz

dbobj3-0.9.3/.gitignore

@@ -0,0 +1,6 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+.eggs/

{dbobj3-0.8.0 → dbobj3-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dbobj3
-Version: 0.8.0
+Version: 0.9.3
 Summary: High-level MySQL/MSSQL/Oracle access module
 Requires-Python: >=3.6
 Requires-Dist: pymysql

{dbobj3-0.8.0 → dbobj3-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dbobj3"
-version = "0.8.0"
+version = "0.9.3"
 description = "High-level MySQL/MSSQL/Oracle access module"
 readme = "README.md"
 requires-python = ">=3.6"
@@ -16,7 +16,7 @@ dependencies = [
 packages = ["src/dbobj3.py"]
 
 [tool.bumpversion]
-current_version = "0.8.0"
+current_version = "0.9.3"
 commit = true
 tag = true
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)"

{dbobj3-0.8.0 → dbobj3-0.9.3}/src/dbobj3.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3.9
+#!/usr/bin/env python3.6
 
 """
 High-Level Access to MySQL, MS SQL Server, Oracle Module and more.
@@ -21,48 +21,92 @@ Example:
 		rsServices.next()
 
 """
-__version__ = "0.8.0"
+__version__ = "0.9.3"
 
+import os
+import importlib  # needed for shim
 from sys import version as sys_version, exit
 from datetime import datetime, date, time
 pyversion = sys_version[0:sys_version.find(' ')]
 using_mysqlclient, using_pymysql = False, False
 
 lstLoadedDrivers = []
-try:
-	#raise ImportError
-	import MySQLdb
-	import MySQLdb.cursors
-	#import MySQLdb.converters
-	# MySQLdb dropped Python3.x support
-	# - For Centos/Python2.x use
-	#   - yum install mysql-devel, MySQL-python
-	#   - pip install mysql-python
-	# - For Python3.x use the fork MySQLdb
-	#   - pip install mysqlclient ( developed by pymysql devs )
-	using_mysqlclient = True
-	lstLoadedDrivers.append({"MySQLdb": "Loaded (MySQL)"})
-except ImportError:
-	lstLoadedDrivers.append({"MySQLdb": "Not Loaded (MySQL)"})
-
-if not using_mysqlclient:
+force_pymysql = os.environ.get("DB_FORCE_PYMYSQL","0") == "1"
+drv_env = os.environ.get("MYSQL_DRIVER","").lower()  # optional: mysqlclient | pymysql
+MySQLdb = None	  # placeholder so global name exists
+pymysql = None	  # placeholder
+
+def _select_mysql_driver():
+	global using_mysqlclient, using_pymysql, MySQLdb, pymysql
+	if force_pymysql or drv_env == "pymysql":
+		import pymysql
+		pymysql.install_as_MySQLdb()
+		import MySQLdb, MySQLdb.cursors, MySQLdb.converters
+		# MySQLdb dropped Python3.x support
+		# - For Centos/Python2.x use
+		#   - yum install mysql-devel, MySQL-python
+		#   - pip install mysql-python
+		# - For Python3.x use the fork MySQLdb
+		#   - pip install mysqlclient ( developed by pymysql devs )
+		using_pymysql = True
+		lstLoadedDrivers.append({"PyMySQL":"Active"})
+		print("MySQL driver: PyMySQL (forced)")
+		return
 	try:
-		# pymysql is a pure python implementation of MySQLdb
-		# Linux:
-		import pymysql as MySQLdb
-		#import MySQLdb.cursors
-		#import MySQLdb.converters
-		# Windows:
-		#import pymysql
-		#pymysql.install_as_MySQLdb()
-		#import pymysql.cursors
-		#import pymysql.converters
+		import MySQLdb, MySQLdb.cursors, MySQLdb.converters
+		using_mysqlclient = True
+		lstLoadedDrivers.append({"mysqlclient":"Active"})
+		print("MySQL driver: mysqlclient")
+	except Exception as e:
+		print(f"mysqlclient import failed ({e}); falling back to PyMySQL")
+		import pymysql
+		pymysql.install_as_MySQLdb()
+		import MySQLdb, MySQLdb.cursors, MySQLdb.converters
 		using_pymysql = True
-		lstLoadedDrivers.append({"pymysql": "Loaded (MySQL)"})
-	except ImportError:
-		#print('Python {0}: could neither import pymysql nor MySQLdb'.format(pyversion))
-		lstLoadedDrivers.append({"pymysql": "Not Loaded (MySQL)"})
-#'''
+		lstLoadedDrivers.append({"PyMySQL":"Active"})
+		print("MySQL driver: PyMySQL (fallback)")
+
+# Minimal shim
+def _ensure_constants_shim():
+	"""
+	Inject only minimal missing constants when using PyMySQL.
+	Avoid constructing synthetic CAPABILITIES to prevent >32-bit signed values.
+	Safe to call multiple times.
+	"""
+	if not using_pymysql:
+		return
+	try:
+		import importlib
+		const_pkg = importlib.import_module("MySQLdb.constants")
+		# COMMAND (only COM_PING needed for legacy ping code)
+		if not hasattr(const_pkg, "COMMAND"):
+			print("Injecting minimal MySQLdb.constants.COMMAND shim for COM_PING")
+			class _DummyCOMMAND:
+				COM_PING = 0x0e
+			const_pkg.COMMAND = _DummyCOMMAND
+		else:
+			if not hasattr(const_pkg.COMMAND, "COM_PING"):
+				print("Injecting MySQLdb.constants.COMMAND.COM_PING shim")
+				const_pkg.COMMAND.COM_PING = 0x0e
+			else:
+				pass
+				#print(f'COMMAND.COM_PING exists: {const_pkg.COMMAND.COM_PING}')
+		# SERVER_STATUS minimal
+		if not hasattr(const_pkg, "SERVER_STATUS"):
+			class _DummySERVER_STATUS:
+				SERVER_STATUS_IN_TRANS = 0x0001
+				SERVER_STATUS_AUTOCOMMIT = 0x0002
+			const_pkg.SERVER_STATUS = _DummySERVER_STATUS
+		# CLIENT flags: only ensure PLUGIN_AUTH if absent; do NOT build CAPABILITIES
+		importlib_client = importlib.import_module("MySQLdb.constants.CLIENT")
+		if not hasattr(importlib_client, "PLUGIN_AUTH"):
+			importlib_client.PLUGIN_AUTH = 0x00080000
+		# If CAPABILITIES exists already, leave it untouched. Do NOT create if missing.
+	except Exception as e:
+		print("MySQL minimal shim error:", e)
+
+_select_mysql_driver()
+_ensure_constants_shim()
 
 def _build_pymysql_conv():
 	"""
@@ -100,6 +144,25 @@ def _build_pymysql_conv():
 	conv[FIELD_TYPE.DATE]	  = (lambda v: date.fromisoformat(v) if v else None)
 	return conv
 
+# helper: unified connection state check
+def _is_mysql_connected(handle):
+	try:
+		# mysqlclient has .open attr; PyMySQL does not
+		# both should support .ping() method
+		if not ( handle and hasattr(handle, "ping") and callable(handle.ping) ):
+			return False
+		else:
+			# mysqlclient: ping() raises exception if not connected
+			db_ping_res = None
+			db_ping_res = handle.ping()
+			# it appears that PyMySQL's ping() returns None when successful, but does it always?
+			if using_mysqlclient:
+				#print("mysqlclient ping() result:", db_ping_res)
+				return True
+			else:
+				return True
+	except Exception:
+		return False
 
 try:
 	import pymssql
@@ -180,12 +243,12 @@ class dbObjCursor:
 		self.create(self.dbType)
 
 	def __del__(self):
-		if(self.dbType == "MYSQL"):
+		if(self.dbType in ("MYSQL", "ORACLE")):
 			try:
 				if self.cursor and self.cursor.connection and self.cursor.connection.open:
 					self.cursor.close()
-			except:
-				pass
+			except Exception as e:
+				print(str(e))
 
 	def create(self, prmDBType="MYSQL"):
 		if(prmDBType=="MYSQL"):
@@ -420,10 +483,11 @@ class dbObjConnection:
 				driverClass="",
 				prmApiBaseUrl="",
 				prmApiKey="",
-				prmApiKeyName="sk"):
+				prmApiKeyName="sk",
+				prmReuseCursor=False):
 		self.set_env( envOracle=envOracle, envProgress=envProgress, driver=driver )
 		self.EOF = 1
-		self.connHandle = 0
+		self.connHandle = None  # was 0; use None for clarity
 		self.dbType = prmDBType.upper()
 		self.msgObj = dbConnMessage()
 		self.lastInsId = 0
@@ -433,6 +497,8 @@ class dbObjConnection:
 		self.using_pymysql = using_pymysql
 		self.drivers = lstLoadedDrivers
 		self.driverClass = driverClass
+		self.reuseCursor = prmReuseCursor
+		self.cursor = None
 		if(prmDBType == "API"):
 			self.apiBaseUrl = prmApiBaseUrl
 			self.apiKeyName = prmApiKeyName
@@ -519,17 +585,21 @@ class dbObjConnection:
 			self.connHandle = MySQLdb.connect(**kwargs)
 			# Uniform autocommit enabling (mysqlclient vs pymysql)
 			try:
+				# mysqlclient
 				self.connHandle.autocommit(True)
 			except Exception:
+				# PyMySQL
 				try:
 					self.connHandle.autocommit = True
 				except Exception:
 					pass
-			if(self.connHandle):
+			if _is_mysql_connected(self.connHandle):
 				self.setConnectSuccess()
 			else:
-				self.setConnectFail()
+				self.connHandle = None
+				self.setConnectFail("Unknown connection state")
 		except Exception as e:
+			self.connHandle = None
 			self.setConnectFail(e)
 		return self.msgObj
 
@@ -663,21 +733,35 @@ class dbObjConnection:
 			print('Connection to {0} Restored.'.format(self.dbType))
 		return self.msgObj
 
+	def ensure_mysql_connection(self):
+		# If connection invalid attempt reconnect (MySQL only)
+		if self.dbType == "MYSQL" and not _is_mysql_connected(self.connHandle):
+			self.reconnect()
+			if not _is_mysql_connected(self.connHandle):
+				raise RuntimeError(f"Cannot ensure connection: MySQL connection dead (host={self.host}, db={self.db})")
+	
 	def getCursor(self):
+		# Reuse existing cursor if requested and still valid
+		if self.cursor and self.reuseCursor and _is_mysql_connected(self.connHandle):
+			return self.cursor
+		# If connection invalid attempt reconnect (MySQL only)
+		self.ensure_mysql_connection()
+		# proceed
 		if(self.dbType == "MYSQL"):
-			return self.mySqlGetCursor()
+			self.cursor = self.mySqlGetCursor()
 		elif(self.dbType == "MSSQL"):
-			return self.mssqlGetCursor()
+			self.cursor = self.mssqlGetCursor()
 		elif(self.dbType == "ORACLE"):
-			return self.oracleGetCursor()
+			self.cursor = self.oracleGetCursor()
 		elif(self.dbType == "SQLITE" or self.dbType == "SQLITE3"):
-			return self.sqlite3GetCursor()
+			self.cursor = self.sqlite3GetCursor()
 		elif(self.dbType == "PROGRESS"):
-			return self.progressGetCursor()
+			self.cursor = self.progressGetCursor()
 		elif(self.dbType == "API"):
-			return self.apiGetCursor()
+			self.cursor = self.apiGetCursor()
 		elif(self.dbType == "JDBC"):
-			return self.jdbcGetCursor()
+			self.cursor = self.jdbcGetCursor()
+		return self.cursor
 
 	def setCursorSuccess(self, cursor):
 		if cursor:
@@ -692,11 +776,14 @@ class dbObjConnection:
 
 	def mySqlGetCursor(self):
 		try:
+			if not _is_mysql_connected(self.connHandle):
+				raise RuntimeError("MySQL connection not established; cannot create cursor")
 			cursor = dbObjCursor(self.connHandle, self.dbType)
 			self.setCursorSuccess(cursor)
 			return cursor
 		except Exception as e:
 			self.setCursorFail(e)
+			raise
 
 	def mssqlGetCursor(self):
 		try:
@@ -797,10 +884,10 @@ class dbObjConnection:
 			self.connHandle.close()
 			self.connHandle = None
 
-	def execute(self, prmSql, *args, **kw):
+	def execute(self, prmSql, *args):
 		"""Execute the SQL and return a record set if applicable"""
 		if(self.dbType == "MYSQL"):
-			return self.mySqlExecute(prmSql, *args, **kw)
+			return self.mySqlExecute(prmSql, *args)
 		if(self.dbType == "MSSQL"):
 			return self.msSqlExecute(prmSql)
 		if(self.dbType == "ORACLE"):
@@ -916,44 +1003,22 @@ class dbObjConnection:
 			self.jdbcPing()
 
 	def mySqlPing(self, reconnect=True):
-		"""
-		Check if the server is alive.
-
-		:param reconnect: If the connection is closed, reconnect.
-		:raise Error: If the connection is closed and reconnect=False.
-		"""
-		if using_pymysql:
-			self.connHandle.ping( reconnect )
-			return
-		elif( not self.connHandle.open ):
-			if reconnect:
-				self.connect()
-				reconnect = False
-			else:
-				raise Exception("Already closed")
-
-		''' This doesn't work with mysqlclient
-		if self.connHandle._sock is None:
-			if reconnect:
-				self.connect()
-				#self.connHandle.connect()
-				reconnect = False
-			else:
-				raise Exception("Already closed")
-		'''
-
 		try:
-			#self.connHandle._execute_command(COMMAND.COM_PING, "")
-			#self.connHandle._read_ok_packet()
-			self.connHandle.ping()
-		except Exception as e:
-			if reconnect:
-				self.connect()
-				self.ping( False )
+			if _is_mysql_connected(self.connHandle):
+				return
+			if not reconnect:
+				raise RuntimeError("MySQL connection not established; cannot ping")
 			else:
-				raise Exception
+				self.reconnect()
+				if not _is_mysql_connected(self.connHandle):
+					raise RuntimeError("MySQL connection not established; cannot ping")
+		except Exception as e:
+			self.setConnectFail(e)
+			raise
+		else:
+			self.setConnectSuccess()
 
-	def setMySqlExecuteFail(self, mySqlCursor, prmSql, e, *args, **kw):
+	def setMySqlExecuteFail(self, mySqlCursor, prmSql, e, *args):
 		self.msgObj.success = False
 		prmSql += '' if not args else ' ({0}) '.format( repr(args) )
 		self.msgObj.message = "SQL Failed: {0} - {1}".format( prmSql, e )
@@ -967,9 +1032,9 @@ class dbObjConnection:
 		finally:
 			return mySqlCursor
 
-	def setMySqlExecuteSuccess(self, mySqlCursor, prmSql, *args, **kw):
+	def setMySqlExecuteSuccess(self, mySqlCursor, prmSql, *args):
 		self.msgObj.success = True
-		self.msgObj.message = "SQL Executed: {0} {1}".format(prmSql,'' if not args else repr(args)+ ' ' + repr(kw))
+		self.msgObj.message = "SQL Executed: {0} {1}".format(prmSql,'' if not args else repr(args))
 		try:
 			mySqlCursor.numFields = len(mySqlCursor.cursor.description)
 			if(mySqlCursor.numRows):
@@ -1007,23 +1072,22 @@ class dbObjConnection:
 				self.msgObj.message += ' or killed process/connection.'
 				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
 				self.reconnect()
-			elif not hasattr(self.connHandle, 'open') or self.connHandle.open==0 or "t connect t" in str(e).lower():
+			elif self.connHandle.open==0 or "Can't connect to" in str(e):
 				self.msgObj.message += ' - Database Connection Closed or Never Established.'
 				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
 				self.reconnect()
-			return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args, **kw )
+			return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args )
 		except Exception as e:
 			mySqlCursor = self.setMySqlExecuteFail(mySqlCursor, prmSql, e, *args)
-			#if self.connHandle.open==0 or "Can't connect to" in str(e): # This line was failing (self.connHandle was an "int") and so not reconnecting
-			if not hasattr(self.connHandle, 'open') or self.connHandle.open==0 or "t connect t" in str(e).lower():
+			if self.connHandle.open==0 or "Can't connect to" in str(e):
 				self.msgObj.message += ' - Database Connection Closed or Never Established.'
 				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
 				self.reconnect()
-				return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args, **kw )
+				return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args )
 			print(self.msgObj.message)
 			return mySqlCursor
 		else:
-			mySqlCursor = self.setMySqlExecuteSuccess(mySqlCursor, prmSql, *args, **kw)
+			mySqlCursor = self.setMySqlExecuteSuccess(mySqlCursor, prmSql, *args)
 			return mySqlCursor
 
 	def msSqlExecute(self, prmSql):
@@ -1121,7 +1185,7 @@ class dbObjConnection:
 			if(r.status_code == requests.codes.ok):
 				retVal = r.json()
 				#print(retVal)
-				if(retVal["error"] == 0):
+				if(retVal["error"].success):
 					apiCursor.lstRecords = retVal["data"]
 					apiCursor.numRows = len(apiCursor.lstRecords)
 					if(apiCursor.numRows > 0):
@@ -1191,14 +1255,14 @@ class dbObjConnection:
 				self.msgObj.message += ' - Database Connection Closed or Never Established.'
 				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
 				self.reconnect()
-			return mySqlCursor if not self.msgObj.success else self.mySqlExecuteMany( prmSql, *args )
+			return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args )
 		except Exception as e:
 			mySqlCursor = self.setMySqlExecuteFail(mySqlCursor, prmSql, e, *args)
 			if self.connHandle.open==0 or "Can't connect to" in str(e):
 				self.msgObj.message += ' - Database Connection Closed or Never Established.'
 				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
 				self.reconnect()
-				return mySqlCursor if not self.msgObj.success else self.mySqlExecuteMany( prmSql, *args )
+				return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args )
 			print(self.msgObj.message)
 			return mySqlCursor
 		else:
@@ -1359,4 +1423,4 @@ if __name__ == '__main__':
 		return odb
 
 	# odb will be the interactively instantiated dbObj connection
-	odb = run_test()
+	odb = run_test()