wmglobalqueue 2.4.5.1__py3-none-any.whl

WMCore/Database/MySQLCore.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+"""
+_MySQLCore_
+
+Handle bind variable parsing for MySQL.
+"""
+
+import copy
+
+from WMCore.Database.DBCore import DBInterface
+from WMCore.Database.ResultSet import ResultSet
+
+def bindVarCompare(a):
+    """
+    _bindVarCompare_
+
+    Bind variables are represented as a tuple with the first element being the
+    variable name and the second being it's position in the query.  We sort on
+    the position in the query.
+    """
+    return a[1]
+
+def stringLengthCompare(a):
+    """
+    _stringLengthCompare_
+
+    Sort comparison function to sort strings by length.
+    Since we want to sort from longest to shortest, this must be reversed when used
+    """
+    return len(a)
+
+
+class MySQLInterface(DBInterface):
+    def substitute(self, origSQL, origBindsList):
+        """
+        _substitute_
+
+        Transform as set of bind variables from a list of dictionaries to a list
+        of tuples:
+
+        b = [ {'bind1':'value1a', 'bind2': 'value2a'},
+        {'bind1':'value1b', 'bind2': 'value2b'} ]
+
+        Will be transformed into:
+
+        b = [ ('value1a', 'value2a'), ('value1b', 'value2b')]
+
+        Don't need to substitute in the binds as executemany does that
+        internally. But the sql will also need to be reformatted, such that
+        :bind_name becomes %s.
+
+        See: http://www.devshed.com/c/a/Python/MySQL-Connectivity-With-Python/5/
+        """
+        if origBindsList == None:
+            return origSQL, None
+
+        origBindsList = self.makelist(origBindsList)
+        origBind = origBindsList[0]
+
+        bindVarPositionList = []
+        updatedSQL = copy.copy(origSQL)
+
+        # We process bind variables from longest to shortest to avoid a shorter
+        # bind variable matching a longer one.  For example if we have two bind
+        # variables: RELEASE_VERSION and RELEASE_VERSION_ID the former will
+        # match against the latter, causing problems.  We'll sort the variable
+        # names by length to guard against this.
+        bindVarNames = list(origBind)
+        bindVarNames.sort(key=stringLengthCompare, reverse=True)
+
+        bindPositions = {}
+        for bindName in bindVarNames:
+            searchPosition = 0
+
+            while True:
+                bindPosition = origSQL.lower().find(":%s" % bindName.lower(),
+                                                    searchPosition)
+                if bindPosition == -1:
+                    break
+
+                if bindPosition not in bindPositions:
+                    bindPositions[bindPosition] = 0
+                    bindVarPositionList.append((bindName, bindPosition))
+                searchPosition = bindPosition + 1
+
+            searchPosition = 0
+            while True:
+                bindPosition = updatedSQL.lower().find(":%s" % bindName.lower(),
+                                                       searchPosition)
+
+                if bindPosition == -1:
+                    break
+
+                left = updatedSQL[0:bindPosition]
+                right = updatedSQL[bindPosition + len(bindName) + 1:]
+                updatedSQL = left + "%s" + right
+
+        bindVarPositionList.sort(key=bindVarCompare)
+
+        mySQLBindVarsList = []
+        for origBind in origBindsList:
+            mySQLBindVars = []
+            for bindVarPosition in bindVarPositionList:
+                mySQLBindVars.append(origBind[bindVarPosition[0]])
+
+            mySQLBindVarsList.append(tuple(mySQLBindVars))
+
+        return (updatedSQL, mySQLBindVarsList)
+
+    def executebinds(self, s = None, b = None, connection = None,
+                     returnCursor = False):
+        """
+        _executebinds_
+
+        Execute a SQL statement that has a single set of bind variables.
+        Transform the bind variables into the format that MySQL expects.
+        """
+        s, b = self.substitute(s, b)
+        return DBInterface.executebinds(self, s, b, connection, returnCursor)
+
+    def executemanybinds(self, s = None, b = None, connection = None,
+                         returnCursor = False):
+        """
+        _executemanybinds_
+
+        Execute a SQL statement that has multiple sets of bind variables.
+        Transform the bind variables into the format that MySQL expects.
+        """
+        newsql, binds = self.substitute(s, b)
+
+        return DBInterface.executemanybinds(self, newsql, binds, connection,
+                                            returnCursor)

WMCore/Database/Oracle/Destroy.py

@@ -0,0 +1,56 @@
+"""
+_Destroy_
+
+Implementation of Destroy for Oracle
+
+"""
+
+from WMCore.Database.DBFormatter import DBFormatter
+
+class Destroy(DBFormatter):
+
+    def execute(self, subscription = None, conn = None, transaction = False):
+
+        sql = """DECLARE
+                 BEGIN
+
+                   execute immediate 'purge recyclebin';
+
+                   -- Tables
+                   FOR o IN (SELECT table_name name FROM user_tables) LOOP
+                     execute immediate 'drop table ' || o.name || ' cascade constraints';
+                   END LOOP;
+
+                   -- Sequences
+                   FOR o IN (SELECT sequence_name name FROM user_sequences) LOOP
+                     execute immediate 'drop sequence ' || o.name;
+                   END LOOP;
+
+                   -- Triggers
+                   FOR o IN (SELECT trigger_name name FROM user_triggers) LOOP
+                     execute immediate 'drop trigger ' || o.name;
+                   END LOOP;
+
+                   -- Synonyms
+                   FOR o IN (SELECT synonym_name name FROM user_synonyms) LOOP
+                     execute immediate 'drop synonym ' || o.name;
+                   END LOOP;
+
+                   -- Functions
+                   FOR o IN (SELECT object_name name FROM user_objects WHERE object_type = 'FUNCTION') LOOP
+                     execute immediate 'drop function ' || o.name;
+                   END LOOP;
+
+                   -- Procedures
+                   FOR o IN (SELECT object_name name FROM user_objects WHERE object_type = 'PROCEDURE') LOOP
+                     execute immediate 'drop procedure ' || o.name;
+                   END LOOP;
+
+                   execute immediate 'purge recyclebin';
+
+                 END;"""
+
+        self.dbi.processData(sql, {}, conn = conn,
+                             transaction = transaction)
+
+        return

WMCore/Database/Oracle/ListUserContent.py

@@ -0,0 +1,19 @@
+"""
+_ListUserContent_
+
+Implementation of ListUserContent for Oracle
+
+"""
+
+from WMCore.Database.DBFormatter import DBFormatter
+
+class ListUserContent(DBFormatter):
+
+    def execute(self, subscription = None, conn = None, transaction = False):
+
+        sql = """SELECT object_name FROM user_objects"""
+
+        result = self.dbi.processData(sql, {}, conn = conn,
+                                      transaction = transaction)
+
+        return self.formatDict(result)

WMCore/Database/Oracle/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+"""
+_Database_
+
+Core Database interface libraries for workload management
+
+
+"""
+__all__ = []

WMCore/Database/ResultSet.py

@@ -0,0 +1,44 @@
+"""
+_ResultSet_
+
+A class to read in a SQLAlchemy result proxy and hold the data, such that the
+SQLAlchemy result sets (aka cursors) can be closed. Make this class look as much
+like the SQLAlchemy class to minimise the impact of adding this class.
+"""
+
+from builtins import object
+import threading
+
+
+class ResultSet(object):
+    def __init__(self):
+        self.data = []
+        self.keys = []
+
+    def close(self):
+        return
+
+    def fetchone(self):
+        if len(self.data) > 0:
+            return self.data[0]
+        else:
+            return []
+
+    def fetchall(self):
+        return self.data
+
+    def add(self, resultproxy):
+
+        myThread = threading.currentThread()
+
+        if resultproxy.closed:
+            return
+        elif resultproxy.returns_rows:
+            for r in resultproxy:
+                if len(self.keys) == 0:
+                    # do not modernize next line. 
+                    # r is a `sqlalchemy.engine.result.RowProxy`, not a `dict`
+                    self.keys.extend(r.keys()) 
+                self.data.append(r)
+
+        return

WMCore/Database/Transaction.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+"""
+_Transaction_
+
+A simple wrapper around DBInterface to make working with transactions simpler
+
+On MySQL transactions only work for innodb tables.
+"""
+
+
+
+import logging
+import time
+
+from WMCore.DataStructs.WMObject import WMObject
+from WMCore.WMException import WMException
+from WMCore.WMExceptions import WMEXCEPTION
+
+class Transaction(WMObject):
+    dbi = None
+
+    def __init__(self, dbinterface = None):
+        """
+        Get the connection from the DBInterface and open a new transaction on it
+        """
+        self.dbi = dbinterface
+        self.conn = None
+        self.transaction = None
+
+    def begin(self):
+        if self.conn == None:
+            self.conn = self.dbi.connection()
+        if self.conn.closed:
+            self.conn = self.dbi.connection()
+
+        if self.transaction == None:
+            self.transaction = self.conn.begin()
+
+        return
+
+    def processData(self, sql, binds={}):
+        """
+        Propagates the request to the proper dbcore backend,
+        and performs checks for lost (or closed) connection.
+        """
+        result = self.dbi.processData(sql, binds, conn = self.conn,
+                                      transaction = True)
+        return result
+
+    def commit(self):
+        """
+        Commit the transaction and return the connection to the pool
+        """
+        if not self.transaction == None:
+            self.transaction.commit()
+
+        if not self.conn == None:
+            self.conn.close()
+        self.conn = None
+        self.transaction = None
+
+    def rollback(self):
+        """
+        To be called if there is an exception and you want to roll back the
+        transaction and return the connection to the pool
+        """
+        if self.transaction:
+            self.transaction.rollback()
+
+        if self.conn:
+            self.conn.close()
+
+        self.conn = None
+        self.transaction = None
+        return
+
+    def rollbackForError(self):
+        """
+        This is called when handling a major exception.  This is because sometimes
+        you can end up in a situation where the transaction appears open, but is not.  In
+        this case, calling a rollback on the transaction will cause an exception, which
+        then destroys all logging and shutdown of the actual code.
+
+        Use only in components.
+        """
+
+        try:
+            self.rollback()
+        except:
+            pass
+        return

WMCore/Database/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+"""
+_Database_
+
+Core Database interface libraries for workload management
+
+
+"""
+__all__ = []