python.db.Databases Class Reference

Inheritance diagram for python.db.Databases:

Collaboration diagram for python.db.Databases:

Public Member Functions
def	resolve_folder_string (cls, folder_name, db_override=None)
def	get_folder (cls, folder_name, db_override=None, read_only=True, create_function=None, also_db=False)
def	resolve_db_string (cls, db_string, read_only=True)
def	get_instance (cls, db_string, read_only=True, create=False)
def	build_folder (cls, db, folder_name, multiversion, record)
def	fetch_for_writing (cls, orig_folder_name, multiversion=True, record=None, create=False, db_override=None)

Static Public Attributes
dictionary	FOLDERS

Detailed Description

Databases helper class. Used as a singleton. (don't instantiate)
Specifies abbreviations for database connection strings and folders

Definition at line 233 of file DQUtils/python/db.py.

Member Function Documentation

build_folder()

def python.db.Databases.build_folder	(		cls,
			db,
			folder_name,
			multiversion,
			record
	)

Create `folder_name` on database instance `db`, with recordspecification
`record`.

Also creates folderset to which folder_name belongs if necessary.

Definition at line 415 of file DQUtils/python/db.py.

    def build_folder(cls, db, folder_name, multiversion, record):
        """
        Create `folder_name` on database instance `db`, with recordspecification
        `record`.
        
        Also creates folderset to which folder_name belongs if necessary.
        """
        from PyCool import cool
        
        folderset_path = dirname(folder_name)
        try:
            db.getFolderSet(folderset_path)
        except Exception as error:
            caught_error = "Folder set %s not found" % folderset_path
            if caught_error not in error.args[0]:
                raise
 
            log.debug("Folderset doesn't exist - creating it.")
            db.createFolderSet(folderset_path, "", True)
 
        if not isinstance(record, cool.RecordSpecification):
            record_spec = cool.RecordSpecification()
            for field in record:
                record_spec.extend(*field)
        else:
            record_spec = record
        
        FV = cool.FolderVersioning
        versioning = FV.MULTI_VERSION if multiversion else FV.SINGLE_VERSION
        folder_spec = cool.FolderSpecification(versioning, record_spec)
        folder = db.createFolder(folder_name, folder_spec)
        payload = cool.Record(record_spec)
        
        return folder, payload
 

fetch_for_writing()

def python.db.Databases.fetch_for_writing	(		cls,
			orig_folder_name,
			multiversion = True,
			record = None,
			create = False,
			db_override = None
	)

Retrieve a folder for writing. Creates it if it doesn't exist.

`folder_name` specifies folder to be queried
`multiversion` specifies COOL versioning mode
`record` is a list of fields to be created in the form:
    [("<field name>", cool.StorageType.<field type>), ...]
    or if None, defaults to one Code record,
    or if isinstance(record, cool.RecordSpecification), uses this.
`create` should the database be created if it doesn't
`db_override` overrides automatic detection of database string

Definition at line 451 of file DQUtils/python/db.py.

    def fetch_for_writing(cls, orig_folder_name, multiversion=True, record=None,
                          create=False, db_override=None):
        """
        Retrieve a folder for writing. Creates it if it doesn't exist.
        
        `folder_name` specifies folder to be queried
        `multiversion` specifies COOL versioning mode
        `record` is a list of fields to be created in the form:
            [("<field name>", cool.StorageType.<field type>), ...]
            or if None, defaults to one Code record,
            or if isinstance(record, cool.RecordSpecification), uses this.
        `create` should the database be created if it doesn't
        `db_override` overrides automatic detection of database string
        """
        from PyCool import cool
        if record is None:
            record = [("Code", cool.StorageType.Int32)]        
 
        database, folder_name = cls.resolve_folder_string(orig_folder_name)
        if db_override:
            database = db_override
        
        try:
            db = cls.get_instance(database, False)
            
        except Exception as error:
            if not create or "The database does not exist" not in error.args[0]:
                raise
            
            from PyCool import cool
            dbService = cool.DatabaseSvcFactory.databaseService()
            
            resolved_database, _ = cls.resolve_db_string(database)
            
            log.info("Database doesn't exist - creating it.")
            db = dbService.createDatabase(resolved_database)
 
        try:
            folder = db.getFolder(folder_name)
            payload = cool.Record(folder.payloadSpecification())
        except Exception as error:
            if not create or "Folder %s not found" % folder_name not in error.args[0]:
                raise
                
            log.debug("Folder doesn't exist - creating it.")
            args = db, folder_name, multiversion, record
            folder, payload = cls.build_folder(*args)
 
        return db, folder, payload

get_folder()

def python.db.Databases.get_folder	(		cls,
			folder_name,
			db_override = None,
			read_only = True,
			create_function = None,
			also_db = False
	)

Retrieve a folder. The `db_override` parameter allows over-riding the
database which comes from the folder string.

Parameters:
    `folder_name` : Folder name or alias to load
    `db_override` : If specified, causes an alternate database string
            to be used.
    `read_only`   : Specifies if a read-only database connection should
            be used.
    `create_function` : If specified, function to be called in case the
                folder doesn't exist. It is passed the database
                connection.
    `also_db`     : Make the return value (db, folder)

Definition at line 304 of file DQUtils/python/db.py.

    def get_folder(cls, folder_name, db_override=None, read_only=True, 
                   create_function=None, also_db=False):
        """
        Retrieve a folder. The `db_override` parameter allows over-riding the
        database which comes from the folder string.
        
        Parameters:
            `folder_name` : Folder name or alias to load
            `db_override` : If specified, causes an alternate database string
                            to be used.
            `read_only`   : Specifies if a read-only database connection should
                            be used.
            `create_function` : If specified, function to be called in case the
                                folder doesn't exist. It is passed the database
                                connection.
            `also_db`     : Make the return value (db, folder)
        """
        
        if read_only:
            assert not create_function, "`read_only` specified with `create`"
        
        database, folder = cls.resolve_folder_string(folder_name, db_override)
        assert database, ("Unable to resolve database for (%s, %s)"
                          % (folder_name, db_override))
        
        create = bool(create_function)
        db = cls.get_instance(database, read_only, create)
        
        try:
            cool_folder = db.getFolder(folder)
        except Exception as error:
            log.debug('HELP! %s', error.args)
            args = str(error)
            log.debug('THIS IS %s', type(args))
            log.debug('Value of boolean: %s', ("not found" in args))
            if not ("cannot be established" in args or
                     "not found" in args
                    ):
                log.exception("Unknown error encountered whilst opening "
                              "database connection to '%s'",
                              database)
                raise
                
            if not create_function:
                log.exception("Database does not exist, `create_function` not "
                              "specified")
                raise
                
            cool_folder = create_function(db)
        if also_db:
            return db, cool_folder
        return cool_folder
        

get_instance()

def python.db.Databases.get_instance	(		cls,
			db_string,
			read_only = True,
			create = False
	)

Open a database connection

Definition at line 391 of file DQUtils/python/db.py.

    def get_instance(cls, db_string, read_only=True, create=False):
        """
        Open a database connection
        """
        res_db_string, read_only = cls.resolve_db_string(db_string, read_only)
            
        try:
            prev_stdout = sys.stdout
            sys.stdout = StringIO()
            try:
                connection = indirectOpen(res_db_string, readOnly=read_only)
            finally:
                sys.stdout = prev_stdout
        except Exception as e:
            if ((e.args and "The database does not exist" in e.args[0]) or
                str(e).find ('The database does not exist') >= 0) and not create:
                log.info("Failed trying to connect to '%s'", res_db_string)
                raise
            from PyCool import cool
            dbService = cool.DatabaseSvcFactory.databaseService()
            connection = dbService.createDatabase(res_db_string)
        return connection
 

resolve_db_string()

def python.db.Databases.resolve_db_string	(		cls,
			db_string,
			read_only = True
	)

Take a database string - if it looks like a filename ending in ".db"
then assume it is a sqlite database with that name.

If the `db_string` is prepended with "WRITE|" then a writable connection
is requested.

If the db_string doesn't contain a "/", then "/" + DEFAULT_DBNAME is
appended.

Definition at line 358 of file DQUtils/python/db.py.

    def resolve_db_string(cls, db_string, read_only=True):
        """
        Take a database string - if it looks like a filename ending in ".db"
        then assume it is a sqlite database with that name.
        
        If the `db_string` is prepended with "WRITE|" then a writable connection
        is requested.
        
        If the db_string doesn't contain a "/", then "/" + DEFAULT_DBNAME is
        appended.
        """
        if "://" in db_string:
            # Assume that the string is already resolved
            return db_string, read_only
        
        if db_string.startswith("WRITE|"):
            assert db_string.count("|") == 1, "Bad db_string format"
            db_string = db_string.split("|")[1]
            read_only = False
        
        sqlite_regex = re.compile(r"(?P<filename>.*?\.db)(?:/?(?P<dbname>[^/]+))?$")
        matched = sqlite_regex.match(db_string)
        if matched:
            filename, dbname = matched.groups()
            dbname = DEFAULT_DBNAME if not dbname else dbname
            db_string = "sqlite://schema=%s;dbname=%s" % (filename, dbname)            
        else:
            if "/" not in db_string:
                return db_string + "/" + DEFAULT_DBNAME, read_only
            
        return db_string, read_only
    

resolve_folder_string()

def python.db.Databases.resolve_folder_string	(		cls,
			folder_name,
			db_override = None
	)

Resolves a simplified folder URI.

Examples:   
    folder_name == "SHIFTOFL" 
will give a connection to COOLOFL_GLOBAL/COMP200
folder /GLOBAL/DETSTATUS/SHIFTOFL
    folder_name == "test.db::SHIFTOFL"
will give a connection to an sqlite database test.db

Priority:
    * Database specified in db_override
    * Database specified in `folder_name`
    * Database specified in cls.FOLDERS[folder_name]

Definition at line 269 of file DQUtils/python/db.py.

    def resolve_folder_string(cls, folder_name, db_override=None):
        """
        Resolves a simplified folder URI.
        
        Examples:   
            folder_name == "SHIFTOFL" 
                will give a connection to COOLOFL_GLOBAL/COMP200
                folder /GLOBAL/DETSTATUS/SHIFTOFL
            folder_name == "test.db::SHIFTOFL"
                will give a connection to an sqlite database test.db
        
        Priority:
            * Database specified in db_override
            * Database specified in `folder_name`
            * Database specified in cls.FOLDERS[folder_name]
        """
        res_database = db_override
        
        # First check - is a database specified in the folder name?
        if "::" in folder_name:
            assert folder_name.count("::") == 1, "Bad folder format"
            database, folder_name = folder_name.split("::")
            
            # If res_database hasn't already been set, do so
            res_database = database if not res_database else res_database
        
        if folder_name in cls.FOLDERS:
            database, res_folder = cls.FOLDERS[folder_name].split("::")
            res_database = database if not res_database else res_database
        else:
            res_folder = folder_name
        
        return res_database, res_folder
    

Member Data Documentation

FOLDERS

dictionary python.db.Databases.FOLDERS

static

Initial value:

=  {
        "DQMFONL"       : "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/DQMFONL",
        "DQMFONLLB"     : "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/DQMFONLLB",
        "SHIFTONL"      : "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/SHIFTONL",
        
        "DQMFOFL"       : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DQMFOFL",
        "DCSOFL"        : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DCSOFL",
        "DQCALCOFL"     : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DQCALCOFL",
        "SHIFTOFL"      : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/SHIFTOFL",
        "LBSUMM"        : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/LBSUMM",
        "VIRTUALFLAGS"  : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/VIRTUALFLAGS",
        
        "DEFECTS"       : "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DEFECTS",
        
        "SOR_Params"    : "COOLONL_TDAQ::/TDAQ/RunCtrl/SOR_Params",
        "EOR_Params"    : "COOLONL_TDAQ::/TDAQ/RunCtrl/EOR_Params",
        "SOR"           : "COOLONL_TDAQ::/TDAQ/RunCtrl/SOR",
        "EOR"           : "COOLONL_TDAQ::/TDAQ/RunCtrl/EOR",
        
        "LBLB"          : "COOLONL_TRIGGER::/TRIGGER/LUMI/LBLB",
        "LBTIME"        : "COOLONL_TRIGGER::/TRIGGER/LUMI/LBTIME",
        "LBLESTONL"     : "COOLONL_TRIGGER::/TRIGGER/LUMI/LBLESTONL",
        "LVL1COUNTERS"  : "COOLONL_TRIGGER::/TRIGGER/LUMI/LVL1COUNTERS",
        "HLTCOUNTERS"   : "COOLOFL_TRIGGER::/TRIGGER/LUMI/HLTCOUNTERS",
        "HLT/Menu"      : "COOLONL_TRIGGER::/TRIGGER/HLT/Menu",
        "LVL1/Menu"     : "COOLONL_TRIGGER::/TRIGGER/LVL1/Menu",
        "Prescales"     : "COOLONL_TRIGGER::/TRIGGER/LVL1/Prescales",
    }

Definition at line 239 of file DQUtils/python/db.py.

---

The documentation for this class was generated from the following file:

• DQUtils/python/db.py