dbobj3 0.6.0__tar.gz → 0.8.0__tar.gz

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

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

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

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

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3.6
+#!/usr/bin/env python3.9
 
 """
 High-Level Access to MySQL, MS SQL Server, Oracle Module and more.
@@ -21,9 +21,10 @@ Example:
 		rsServices.next()
 
 """
-__version__ = "0.6.0"
+__version__ = "0.8.0"
 
 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
 
@@ -32,10 +33,10 @@ 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 
+	#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 )
@@ -49,11 +50,11 @@ if not using_mysqlclient:
 		# pymysql is a pure python implementation of MySQLdb
 		# Linux:
 		import pymysql as MySQLdb
-		import MySQLdb.cursors
-		import MySQLdb.converters
+		#import MySQLdb.cursors
+		#import MySQLdb.converters
 		# Windows:
 		#import pymysql
-		#pymysql.install_as_MySQLdb() 
+		#pymysql.install_as_MySQLdb()
 		#import pymysql.cursors
 		#import pymysql.converters
 		using_pymysql = True
@@ -63,6 +64,43 @@ if not using_mysqlclient:
 		lstLoadedDrivers.append({"pymysql": "Not Loaded (MySQL)"})
 #'''
 
+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
+
+
 try:
 	import pymssql
 	lstLoadedDrivers.append({"pymssql": "Loaded (Microsoft SQL Server)"})
@@ -304,35 +342,6 @@ class dbObjCursor:
 		else:
 			self.EOF = 1
 
-		'''
-		if(self.recordPointer <= self.numRows):  #???? what about 0?
-			self.fieldByName = {}
-			self.fieldNames = []
-			print(self.recordPointer)
-			print(self.numRows)
-			print(self.cursor)
-			print("-----------------------------------------------------")
-			#print(self.cursor.description)
-			print(self.lstRecords)
-			print(self.recordPointer <= self.numRows)
-			print(self.recordPointer)
-			print(self.numRows)
-			print(type(self.recordPointer))
-			print(type(self.numRows))
-			columns = [column[0] for column in self.cursor.description]
-			self.fieldByName = (dict(zip(columns, self.lstRecords[self.recordPointer])))
-			#fieldNo = 0
-			#for cursorFieldname in self.cursor.description:
-			#	self.fieldByName[cursorFieldname[0]] = self.lstRecords[(self.recordPointer-1)][fieldNo]
-			#	self.fieldNames.append(cursorFieldname[0])
-			#	fieldNo = fieldNo + 1
-			self.fields = self.fieldByName
-			self.recordPointer += 1
-			self.EOF = 0
-		else:
-			self.EOF = 1
-		'''
-
 	def first(self):
 		"""Move to the next record in the record set and loads the data into the fields property.  Sets EOF at end of records."""
 		if(self.dbType == "MYSQL"):
@@ -394,18 +403,18 @@ class dbObjConnection:
 	dbObjConnection is the database connection object.  It is responsible for connecting to
 	the database.  This object supports access to MySQL, Microsoft SQL Server, Oracle,
 	SQLite3, and Progress DataDirect.
-	
+
 	prmDBType can be:  MYSQL, MSSQL, ORACLE, SQLITE3, PROGRESS, API, or JDBC
 
 	"""
-	def __init__(self, 
-				prmDBType="MYSQL", 
-				prmHost="localhost", 
-				prmDb="", 
-				prmUser="", 
-				prmPass="", 
-				prmPort=3306, 
-				envOracle={}, 
+	def __init__(self,
+				prmDBType="MYSQL",
+				prmHost="localhost",
+				prmDb="",
+				prmUser="",
+				prmPass="",
+				prmPort=3306,
+				envOracle={},
 				envProgress={},
 				driver='',
 				driverClass="",
@@ -499,8 +508,23 @@ 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)
+			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:
+				self.connHandle.autocommit(True)
+			except Exception:
+				try:
+					self.connHandle.autocommit = True
+				except Exception:
+					pass
 			if(self.connHandle):
 				self.setConnectSuccess()
 			else:
@@ -544,7 +568,7 @@ class dbObjConnection:
 			self.setConnectFail(e)
 		return self.msgObj
 
-	def progressConnect(self, prmHost, prmDb, prmUser, prmPass, prmPort=35078, envProgress={}, driver=None):
+	def progressConnect(self, prmHost, prmDb, prmUser, prmPass, prmPort=35028, envProgress={}, driver=None):
 		try:
 			driver = driver or self.driver
 			strCnxn = 'Driver={};'.format(driver)
@@ -599,10 +623,10 @@ class dbObjConnection:
 
 			You may also need to increase the innodb_log_file_size mysql variable in your my.cnf configuration
 			to for example 128MB or higher.
-			
-			Server dropped an incorrect or too large packet. If mysqld gets a packet that is too large or 
-			incorrect, it assumes that something has gone wrong with the client and closes the connection. 
-			To fix, you can increase the maximal packet size limit max_allowed_packet in my.cnf file, 
+
+			Server dropped an incorrect or too large packet. If mysqld gets a packet that is too large or
+			incorrect, it assumes that something has gone wrong with the client and closes the connection.
+			To fix, you can increase the maximal packet size limit max_allowed_packet in my.cnf file,
 			eg. set max_allowed_packet = 128M, then restart your MySQL server.
 		'''
 
@@ -613,16 +637,16 @@ class dbObjConnection:
 
 		self.msgObj.success = False
 
-		while ( self.autoreconnect 
-				and( self.reconnect_attempts <= self.reconnect_max ) 
+		while ( self.autoreconnect
+				and( self.reconnect_attempts <= self.reconnect_max )
 				and not self.msgObj.success ):
-			
+
 			self.reconnect_attempts += 1
 			if self.reconnect_attempts > self.reconnect_max:
 				self.msgObj.message += ' - Exceeded Maximum autoreconnect Attempts to {0} ({1} attempts).'.format(self.dbType, self.reconnect_attempts)
 				print(self.msgObj.message)
 				return self.msgObj
-			
+
 			print("ATTEMPT {0} of Reconnect to {1}".format(self.reconnect_attempts,self.dbType))
 			if(self.dbType == "MYSQL"):
 				self.mySqlConnect(self.host, self.db, self.user, self.passwd, self.port)
@@ -634,7 +658,7 @@ class dbObjConnection:
 				self.sqlite3Connect(self.db)
 			elif(self.dbType == "PROGRESS"):
 				self.progressConnect(self.host, self.db, self.user, self.passwd, self.port)
-		
+
 		if self.msgObj.success:
 			print('Connection to {0} Restored.'.format(self.dbType))
 		return self.msgObj
@@ -764,16 +788,19 @@ class dbObjConnection:
 
 	def apiDisconnect(self):
 		pass
+		if self.connHandle:
+			self.connHandle.close()
+			self.connHandle = None
 
 	def jdbcDisconnect(self):
 		if self.connHandle:
 			self.connHandle.close()
 			self.connHandle = None
 
-	def execute(self, prmSql, *args):
+	def execute(self, prmSql, *args, **kw):
 		"""Execute the SQL and return a record set if applicable"""
 		if(self.dbType == "MYSQL"):
-			return self.mySqlExecute(prmSql, *args)
+			return self.mySqlExecute(prmSql, *args, **kw)
 		if(self.dbType == "MSSQL"):
 			return self.msSqlExecute(prmSql)
 		if(self.dbType == "ORACLE"):
@@ -787,6 +814,29 @@ class dbObjConnection:
 		if(self.dbType in ("JDBC")):
 			return self.jdbcExecute(prmSql)
 
+	def executemany(self, prmSql, *args):
+		"""Execute the SQL and return a record set if applicable"""
+		if(self.dbType == "MYSQL"):
+			return self.mySqlExecuteMany(prmSql, *args)
+		if(self.dbType == "MSSQL"):
+			return
+			#return self.msSqlExecuteMany(prmSql)
+		if(self.dbType == "ORACLE"):
+			return
+			#return self.oracleExecuteMany(prmSql)
+		if(self.dbType in ("SQLITE","SQLITE3")):
+			return
+			#return self.sqlite3ExecuteMany(prmSql)
+		if(self.dbType in ("PROGRESS")):
+			return
+			#return self.progressExecuteMany(prmSql)
+		if(self.dbType in ("API")):
+			return
+			#return self.apiExecuteMany(prmSql)
+		if(self.dbType in ("JDBC")):
+			return
+			#return self.jdbcExecuteMany(prmSql)
+
 	def fetchall(self, prmSql, *args):
 		"""Returns result set as a list of dictionaries"""
 		rset = []
@@ -796,21 +846,18 @@ class dbObjConnection:
 			crsr.next()
 		return rset
 
-
 	def fetchone(self, prmSql, *args):
 		"""Returns a single row as a dictionary"""
 		crsr = self.execute( prmSql, *args )
 		dictRow = {} if crsr.EOF else crsr.fields
 		return dictRow
 
-
 	def fetchval(self, prmSql, *args):
 		"""Returns a single value"""
 		dictRow = self.fetchone( prmSql, *args )
 		listVals = list(dictRow.values())
 		return None if not listVals else listVals[0]
 
-
 	def fetchlistvals(self, prmSql, *args):
 		"""Returns a list of vals; if more than one key/column, returns a list of value tuples"""
 		listvals = []
@@ -822,13 +869,12 @@ class dbObjConnection:
 			listvals.append( vals )
 		return listvals
 
-
 	def insert(self, table, prmDict, update_on_duplicate=False):
 		if update_on_duplicate:
 			keystr = ','.join(prmDict.keys())
 			valstr = ','.join(['%s' for i in range(len(prmDict.keys()))])
 			setstr = ",".join([ "{k}=%s".format(k=k) for k in prmDict.keys()])
-			args = tuple(prmDict.values()) * 2						
+			args = tuple(prmDict.values()) * 2
 			strSql = "INSERT INTO {table} ({keystr}) VALUES ({valstr})".format(table=table,keystr=keystr,valstr=valstr)
 			strSql += "ON DUPLICATE KEY UPDATE {setstr}".format(setstr=setstr)
 			return self.execute(strSql, *args)
@@ -850,20 +896,24 @@ class dbObjConnection:
 			self.mySqlPing()
 		# untested
 		elif(self.dbType == "MSSQL"):
-			pass
+			return
 			self.msSqlPing()
 		# does not work
 		elif(self.dbType == "ORACLE"):
-			pass
+			return
 			self.oraclePing()
 		# untested
 		elif(self.dbType in ("SQLITE", "SQLITE3")):
-			pass
+			return
 			self.sqlite3Ping()
 		# untested
 		elif(self.dbType == "PROGRESS"):
-			pass
+			return
 			self.progressPing()
+		# untested
+		elif(self.dbType == "JDBC"):
+			return
+			self.jdbcPing()
 
 	def mySqlPing(self, reconnect=True):
 		"""
@@ -903,7 +953,7 @@ class dbObjConnection:
 			else:
 				raise Exception
 
-	def setMySqlExecuteFail(self, mySqlCursor, prmSql, e, *args):
+	def setMySqlExecuteFail(self, mySqlCursor, prmSql, e, *args, **kw):
 		self.msgObj.success = False
 		prmSql += '' if not args else ' ({0}) '.format( repr(args) )
 		self.msgObj.message = "SQL Failed: {0} - {1}".format( prmSql, e )
@@ -917,9 +967,9 @@ class dbObjConnection:
 		finally:
 			return mySqlCursor
 
-	def setMySqlExecuteSuccess(self, mySqlCursor, prmSql, *args):
+	def setMySqlExecuteSuccess(self, mySqlCursor, prmSql, *args, **kw):
 		self.msgObj.success = True
-		self.msgObj.message = "SQL Executed: {0} {1}".format(prmSql,'' if not args else repr(args))
+		self.msgObj.message = "SQL Executed: {0} {1}".format(prmSql,'' if not args else repr(args)+ ' ' + repr(kw))
 		try:
 			mySqlCursor.numFields = len(mySqlCursor.cursor.description)
 			if(mySqlCursor.numRows):
@@ -932,10 +982,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)
@@ -953,22 +1007,23 @@ 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 self.connHandle.open==0 or "Can't connect to" in str(e):
+			elif not hasattr(self.connHandle, 'open') or self.connHandle.open==0 or "t connect t" in str(e).lower():
 				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 )
+			return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args, **kw )
 		except Exception as e:
 			mySqlCursor = self.setMySqlExecuteFail(mySqlCursor, prmSql, e, *args)
-			if self.connHandle.open==0 or "Can't connect to" in str(e):
+			#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():
 				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 )
+				return mySqlCursor if not self.msgObj.success else self.mySqlExecute( prmSql, *args, **kw )
 			print(self.msgObj.message)
 			return mySqlCursor
 		else:
-			mySqlCursor = self.setMySqlExecuteSuccess(mySqlCursor, prmSql, *args)
+			mySqlCursor = self.setMySqlExecuteSuccess(mySqlCursor, prmSql, *args, **kw)
 			return mySqlCursor
 
 	def msSqlExecute(self, prmSql):
@@ -1113,6 +1168,101 @@ class dbObjConnection:
 		jdbcCursor.next()
 		return jdbcCursor
 
+	def mySqlExecuteMany(self, prmSql, *args):
+		# https://dev.mysql.com/doc/connector-python/en/connector-python-api-mysqlcursor-executemany.html
+		mySqlCursor = self.getCursor()
+		try:
+			mySqlCursor.cursor.executemany(prmSql, *args)
+			self.msgObj.message = "SQL Executed: "+prmSql
+			self.msgObj.success = True
+			mySqlCursor.numRows = mySqlCursor.cursor.rowcount
+			self.lastInsId = self.connHandle.insert_id()
+		except MySQLdb.OperationalError as e:
+			self.msgObj.message += ' - OperationalError: {0}'.format(e)
+			mySqlCursor = self.setMySqlExecuteFail(mySqlCursor, prmSql, e, *args)
+			print(self.msgObj.message)
+			if "server has gone away" in str(e):
+				self.msgObj.message += ' - Lost Connection Due to timeout,'
+				self.msgObj.message += ' innodb_log_file_size, dropped incorrect/large packet,'
+				self.msgObj.message += ' or killed process/connection.'
+				self.msgObj.message += ' connHandle={0}, connHandle.open={1}'.format(self.connHandle,self.connHandle.open)
+				self.reconnect()
+			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.mySqlExecuteMany( 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 )
+			print(self.msgObj.message)
+			return mySqlCursor
+		else:
+			mySqlCursor = self.setMySqlExecuteSuccess(mySqlCursor, prmSql, *args)
+			return mySqlCursor
+
+	def getTransactionIsolation(self):
+		# untested
+		if(self.dbType == "MYSQL"):
+			return
+			self.mySqlGetTransactionIsolation()
+		# will not work
+		elif(self.dbType == "MSSQL"):
+			return
+			self.msSqlGetTransactionIsolation()
+		# untested
+		elif(self.dbType == "ORACLE"):
+			return
+			self.oracleGetTransactionIsolation()
+		# untested
+		elif(self.dbType in ("SQLITE", "SQLITE3")):
+			return
+			self.sqlite3GetTransactionIsolation()
+		# untested
+		elif(self.dbType == "PROGRESS"):
+			return
+			self.progressGetTransactionIsolation()
+		# untested
+		elif(self.dbType == "JDBC"):
+			return self.jdbcGetTransactionIsolation()
+
+	def setTransactionIsolation(self, lvl):
+		# untested
+		if(self.dbType == "MYSQL"):
+			return
+			self.mySqlSetTransactionIsolation(lvl)
+		# will not work
+		elif(self.dbType == "MSSQL"):
+			return
+			self.msSqlSetTransactionIsolation(lvl)
+		# does not work
+		elif(self.dbType == "ORACLE"):
+			return
+			self.oracleSetTransactionIsolation(lvl)
+		# untested
+		elif(self.dbType in ("SQLITE", "SQLITE3")):
+			return
+			self.sqlite3SetTransactionIsolation(lvl)
+		# untested
+		elif(self.dbType == "PROGRESS"):
+			return
+			self.progressSetTransactionIsolation(lvl)
+		# untested
+		elif(self.dbType == "JDBC"):
+			return self.jdbcSetTransactionIsolation(lvl)
+
+	def jdbcGetTransactionIsolation(self):
+		r = self.connHandle.jconn.getTransactionIsolation()
+		return r
+
+	def jdbcSetTransactionIsolation(self, lvl):
+		r = self.connHandle.jconn.setTransactionIsolation(lvl)
+		return r
+
 	def commit(self):
 		if(self.dbType == "MYSQL"):
 			self.connHandle.commit()
@@ -1164,11 +1314,11 @@ if __name__ == '__main__':
 		running_test = getInput("Run MySQL Test?  ")
 		if running_test.lower() not in ('n','no'):
 			odb = dbtest()
-		
+
 		print('\n')
 
 		if not odb:
-			print( "Type run_test() to interactively test db connection") 
+			print( "Type run_test() to interactively test db connection")
 		else:
 			sqls, rset = sqltest( odb )
 			print( "\n - autoreconnect is True by default for MySQL, so if a connection socket error occurs (MySQL tested), it should auto reconnect" )
@@ -1196,17 +1346,17 @@ if __name__ == '__main__':
 			print( "now odb.reconnect_attempts = {0}".format(odb.reconnect_attempts) )
 			print( "setting odb.msgObj.message = ''" )
 			odb.msgObj.message = ''
-			
+
 			print( "rerunning {s}".format(s=sqls) )
-			
+
 			try:
 				sqls, rset = sqltest( odb, sqls )
 			except Exception as e:
 				print( "\nException in dbobj: {e}\n".format(e=e) )
-			
+
 			print( "setting odb.autoreconnect back to True")
 			odb.autoreconnect = True
 		return odb
 
-	# odb will be the interactively instantiated dbObj connection 
-	odb = run_test()
+	# odb will be the interactively instantiated dbObj connection
+	odb = run_test()