dbobj3 0.5.0__tar.gz → 0.7.0__tar.gz

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

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

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

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

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

@@ -21,7 +21,7 @@ Example:
 		rsServices.next()
 
 """
-__version__ = "0.5.0"
+__version__ = "0.7.0"
 
 from sys import version as sys_version, exit
 pyversion = sys_version[0:sys_version.find(' ')]
@@ -33,9 +33,9 @@ try:
 	import MySQLdb
 	import MySQLdb.cursors
 	import MySQLdb.converters
-	# MySQLdb dropped Python3.x support 
-	# - For Centos/Python2.x use 
-	#   - yum install mysql-devel, MySQL-python 
+	# 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 )
@@ -53,7 +53,7 @@ if not using_mysqlclient:
 		import MySQLdb.converters
 		# Windows:
 		#import pymysql
-		#pymysql.install_as_MySQLdb() 
+		#pymysql.install_as_MySQLdb()
 		#import pymysql.cursors
 		#import pymysql.converters
 		using_pymysql = True
@@ -95,9 +95,15 @@ try:
 	import requests
 	lstLoadedDrivers.append({"requests": "Loaded (API)"})
 except ImportError:
-	#print('could not import pyodbc')
+	#print('could not import requests')
 	lstLoadedDrivers.append({"requests": "Not Loaded (API)"})
 
+try:
+	import jaydebeapi
+	lstLoadedDrivers.append({"jaydebeapi": "Loaded (JDBC)"})
+except ImportError:
+	lstLoadedDrivers.append({"jaydebeapi": "Not Loaded (JDBC)"})
+
 try:
 	import json
 except ImportError:
@@ -156,6 +162,8 @@ class dbObjCursor:
 			self.createProgress()
 		elif(prmDBType=="API"):
 			self.createAPI()
+		elif(prmDBType=="JDBC"):
+			self.createJDBC()
 
 	def createMySql(self):
 		self.cursor = self.connection.cursor(MySQLdb.cursors.DictCursor)
@@ -177,6 +185,9 @@ class dbObjCursor:
 	def createAPI(self):
 		self.lstRecords = []
 
+	def createJDBC(self):
+		self.cursor = self.connection.cursor()
+
 	def moveNext(self):
 		"""Same as next"""
 		self.next()
@@ -195,6 +206,8 @@ class dbObjCursor:
 			self.progressNext()
 		elif(self.dbType == "API"):
 			self.apiNext()
+		elif(self.dbType == "JDBC"):
+			self.jdbcNext()
 
 	def mySqlNext(self):
 		resultSet = self.cursor.fetchone()
@@ -275,6 +288,22 @@ class dbObjCursor:
 		else:
 			self.EOF = 1
 
+	def jdbcNext(self):
+		try:
+			resultSet = self.cursor.fetchone()
+		except Exception as e:
+			print(e)
+			self.EOF = 1
+			return
+		if(resultSet != None):
+			columns = [column[0] for column in self.cursor.description]
+			self.fieldByName = (dict(zip(columns, resultSet)))
+			#self.fieldNames.append(cursorFieldname[0])
+			self.fields = self.fieldByName
+			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"):
@@ -323,24 +352,34 @@ class dbObjCursor:
 			self.recordPointer = 1
 		#print('progressExecute (fetchs all) time.time()-t0: ',str(round(time.time()-t0,3)),' seconds')
 
+	def jdbcExecute(self, prmSql):
+		self.cursor.execute(prmSql)
+		self.lstRecords = self.cursor.fetchall()
+		self.numRows = len(self.lstRecords)
+		self.numFields = len(self.cursor.description)
+		if(self.numRows > 0):
+			self.recordPointer = 1
+
 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, or API
+
+	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="",
 				prmApiBaseUrl="",
 				prmApiKey="",
 				prmApiKeyName="sk"):
@@ -355,6 +394,7 @@ class dbObjConnection:
 		self.reconnect_attempts = 0
 		self.using_pymysql = using_pymysql
 		self.drivers = lstLoadedDrivers
+		self.driverClass = driverClass
 		if(prmDBType == "API"):
 			self.apiBaseUrl = prmApiBaseUrl
 			self.apiKeyName = prmApiKeyName
@@ -416,6 +456,8 @@ class dbObjConnection:
 				return self.sqlite3Connect(prmDb)
 			elif(self.dbType == "PROGRESS"):
 				return self.progressConnect(prmHost, prmDb, prmUser, prmPass, prmPort)
+			elif(self.dbType == "JDBC"):
+				return self.jdbcConnect(prmHost, prmDb, prmUser, prmPass)
 
 	def setConnectSuccess(self):
 		self.reconnect_attempts = 0
@@ -473,7 +515,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)
@@ -506,6 +548,18 @@ class dbObjConnection:
 			self.setConnectSuccess()
 		return self.msgObj
 
+	def jdbcConnect(self, prmConnString, prmDriver, prmUser, prmPass):
+		try:
+			self.connHandle = jaydebeapi.connect(self.driverClass, prmConnString, [prmUser, prmPass], prmDriver)
+			if(self.connHandle):
+				self.setConnectSuccess()
+			else:
+				self.setConnectFail()
+		except Exception as e:
+			self.setConnectFail(e)
+			print(e)
+		return self.msgObj
+
 	def reconnect(self):
 		# https://dev.mysql.com/doc/refman/8.0/en/gone-away.html
 		mysql_lost_msg = '''
@@ -516,10 +570,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.
 		'''
 
@@ -530,16 +584,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)
@@ -551,7 +605,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
@@ -569,6 +623,8 @@ class dbObjConnection:
 			return self.progressGetCursor()
 		elif(self.dbType == "API"):
 			return self.apiGetCursor()
+		elif(self.dbType == "JDBC"):
+			return self.jdbcGetCursor()
 
 	def setCursorSuccess(self, cursor):
 		if cursor:
@@ -629,6 +685,14 @@ class dbObjConnection:
 		except Exception as e:
 			self.setCursorFail(e)
 
+	def jdbcGetCursor(self):
+		try:
+			cursor = dbObjCursor(self.connHandle, self.dbType)
+			self.setCursorSuccess(cursor)
+			return cursor
+		except Exception as e:
+			self.setCursorFail(e)
+
 	def disconnect(self):
 		"""Disconnect the connection handle to the database"""
 		if(self.dbType == "MYSQL"):
@@ -641,6 +705,8 @@ class dbObjConnection:
 			self.sqlite3Disconnect()
 		elif(self.dbType == "PROGRESS"):
 			self.progressDisconnect()
+		elif(self.dbType == "JDBC"):
+			self.jdbcDisconnect()
 
 	def mySqlDisconnect(self):
 		if self.connHandle and self.connHandle.open:
@@ -669,6 +735,14 @@ 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):
 		"""Execute the SQL and return a record set if applicable"""
@@ -684,7 +758,31 @@ class dbObjConnection:
 			return self.progressExecute(prmSql)
 		if(self.dbType in ("API")):
 			return self.apiExecute(prmSql)
+		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"""
@@ -695,42 +793,35 @@ 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 = []
 		rset = self.fetchall(prmSql, *args)
 		if not rset:
 			return []
-		keys = list(rset[0].keys())
 		for dictRow in rset:
-			if len(keys) == 1:
-				listvals.append( dictRow.get(keys[0]) )
-			else:
-				listvals.append( tuple( dictRow.get(k) for k in keys  ) )
+			vals = list(dictRow.values())[0] if len(dictRow.values())==1 else list(dictRow.values())
+			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)
@@ -752,20 +843,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):
 		"""
@@ -837,7 +932,10 @@ class dbObjConnection:
 	def mySqlExecute(self, prmSql, *args):
 		mySqlCursor = self.getCursor()
 		try:
-			mySqlCursor.cursor.execute(prmSql, args)
+			if args:
+				mySqlCursor.cursor.execute(prmSql, args)
+			else:
+				mySqlCursor.cursor.execute(prmSql)
 			self.msgObj.message = "SQL Executed: "+prmSql
 			self.msgObj.success = True
 			mySqlCursor.numRows = mySqlCursor.cursor.rowcount
@@ -994,6 +1092,119 @@ class dbObjConnection:
 			apiCursor.success = False
 		return apiCursor
 
+	def jdbcExecute(self, prmSql):
+		jdbcCursor = self.getCursor()
+		try:
+			jdbcCursor.cursor.execute(prmSql)
+			self.msgObj.message = "SQL Executed: "+prmSql
+			self.msgObj.success = True
+		except Exception as e:
+			self.msgObj.message = "SQL Failed: "+prmSql+" - "+str(e)
+			self.msgObj.success = False
+			jdbcCursor.numFields = 0
+			jdbcCursor.numRows = 0
+			jdbcCursor.EOF = 1
+			jdbcCursor.success = False
+			print(self.msgObj.message)
+			return jdbcCursor
+		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.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.mySqlExecute( 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()
@@ -1045,11 +1256,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" )
@@ -1077,17 +1288,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()