dbobj3 0.7.0__tar.gz → 0.9.0__tar.gz

{dbobj3-0.7.0 → dbobj3-0.9.0}/PKG-INFO

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

{dbobj3-0.7.0 → dbobj3-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dbobj3"
-version = "0.7.0"
+version = "0.9.0"
 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.7.0"
+current_version = "0.9.0"
 commit = true
 tag = true
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)"

{dbobj3-0.7.0 → dbobj3-0.9.0}/src/dbobj3.py

@@ -21,47 +21,147 @@ Example:
 		rsServices.next()
 
 """
-__version__ = "0.7.0"
+__version__ = "0.9.0"
 
+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():
+	"""
+	Return a PyMySQL conversion dict that parses DATETIME / TIMESTAMP / DATE
+	into real Python datetime/date objects (mimicking mysqlclient behavior).
+	"""
+	if not using_pymysql:
+		return None
+	from pymysql.constants import FIELD_TYPE
+	from pymysql.converters import conversions
+	conv = conversions.copy()
+
+	def _parse_dt(val):
+		if val is None:
+			return None
+		v = val.strip()
+		# Try common formats (truncate fractional seconds)
+		base = v.split('.')[0]
+		for fmt in ("%Y-%m-%d %H:%M:%S",
+					"%Y-%m-%d %H:%M",
+					"%Y-%m-%dT%H:%M:%S",
+					"%Y-%m-%d"):
+			try:
+				return datetime.strptime(base, fmt)
+			except Exception:
+				pass
+		# ISO fallback
+		try:
+			return datetime.fromisoformat(v.replace('Z',''))
+		except Exception:
+			return v  # leave as original string if unparseable
+
+	conv[FIELD_TYPE.DATETIME]  = _parse_dt
+	conv[FIELD_TYPE.TIMESTAMP] = _parse_dt
+	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()
+			if using_mysqlclient:
+				print("mysqlclient ping() result:", db_ping_res)
+				return True
+			else:
+				return True
+	except Exception:
+		return False
 
 try:
 	import pymssql
@@ -142,12 +242,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"):
@@ -382,10 +482,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
@@ -395,6 +496,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
@@ -470,13 +573,33 @@ class dbObjConnection:
 
 	def mySqlConnect(self, prmHost, prmDb, prmUser, prmPass, prmPort=3306):
 		try:
-			self.connHandle = MySQLdb.connect(host=prmHost,db=prmDb,user=prmUser,passwd=prmPass,port=prmPort)
-			self.connHandle.autocommit(True)
-			if(self.connHandle):
+
+			kwargs = dict(host=prmHost, db=prmDb, user=prmUser, passwd=prmPass, port=prmPort)
+			if using_pymysql:
+				conv = _build_pymysql_conv()
+				if conv:
+					kwargs["conv"] = conv
+				# Ensure utf8mb4 for PyMySQL
+				kwargs.setdefault("charset", "utf8mb4")
+				kwargs.setdefault("autocommit", True)
+			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 _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
 
@@ -610,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:
@@ -639,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:
@@ -863,42 +1003,20 @@ 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):
 		self.msgObj.success = False
@@ -929,10 +1047,14 @@ class dbObjConnection:
 		finally:
 			return mySqlCursor
 
-	def mySqlExecute(self, prmSql, *args):
+	def mySqlExecute(self, prmSql, *args, **kw):
 		mySqlCursor = self.getCursor()
 		try:
-			if args:
+			if not hasattr(self.connHandle, 'open') or self.connHandle.open==0 :
+				self.reconnect()
+			if kw:
+				mySqlCursor.cursor.execute(prmSql, kw)
+			elif args:
 				mySqlCursor.cursor.execute(prmSql, args)
 			else:
 				mySqlCursor.cursor.execute(prmSql)
@@ -1063,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):