querying.connection Class Reference

Inheritance diagram for querying.connection:

Public Member Functions
def	__init__ (self, connection_data, mode=None, map_blobs=False, secrets=None, pooling=False)
def	close_session (self)
def	commit (self)
def	global_tag (self, pkargs)
def	global_tag_map (self, pkargs)
def	hard_close (self)
def	iov (self, pkargs)
def	model (self, model_name)
def	object (self, model, pk_to_value)
def	payload (self, pkargs)
def	rollback (self)
def	search_everything (self, string, amount=10)
def	setup (self)
def	tag (self, pkargs)
def	tag_authorization (self, pkargs)
def	tear_down (self)
def	write (self, object)
def	write_and_commit (self, object)

Static Public Member Functions
def	build_frontier_url (db_name, schema)
def	build_oracle_url (user, pwd, db_name)

Public Attributes
	connection_data
	engine
	factory
	models
	radius
	range
	regexp
	schema
	session
	sessionmaker

Private Member Functions
def	_oracle_match_format (self, string)

Static Private Member Functions
def	_cms_frontier_string (database, schema="cms_conditions")
def	_cms_oracle_string (user, pwd, db_name)
def	_get_CMS_frontier_connection_string (database)

Private Attributes
	_pooling

Detailed Description

Definition at line 23 of file querying.py.

Constructor & Destructor Documentation

__init__()

def querying.connection.__init__	(		self,
			connection_data,
			mode = None,
			map_blobs = False,
			secrets = None,
			pooling = False
	)

Definition at line 35 of file querying.py.

    def __init__(self, connection_data, mode=None, map_blobs=False, secrets=None, pooling=False):

        self._pooling = pooling

        # add querying utility properties
        # these must belong to the connection since the way in which their values are handled
        # depends on the database being connected to.
        self.range = models.Range
        self.radius = models.Radius
        self.regexp = models.RegExp
        self.regexp.connection_object = self

        if type(connection_data) in [str, str]:
            # if we've been given a connection string, process it
            self.connection_data = new_connection_dictionary(connection_data, secrets=secrets, mode=mode)
            self.schema = self.connection_data.get("schema") if self.connection_data.get("schema") != None else ""

            self.range.database_type = self.connection_data["host"]
            self.radius.database_type = self.connection_data["host"]
            self.regexp.database_type = self.connection_data["host"]
        else:
            self.connection_data = connection_data
            # assume we have an engine
            # we need to take the string representation so we know which type of db we're aiming at
            engine_string = str(connection_data)
            db_type = None
            if "oracle" in engine_string:
                db_type = "oracle"
            elif "frontier" in engine_string:
                db_type = "frontier"
            elif "sqlite" in engine_string:
                db_type = "sqlite"

            self.range.database_type = db_type
            self.radius.database_type = db_type
            self.regexp.database_type = db_type

        from . import models as ms
        self.models = ms.generate(map_blobs)
        #self.base = self.models["Base"]

Member Function Documentation

_cms_frontier_string()

def querying.connection._cms_frontier_string (   database,   schema = "cms_conditions"  )

staticprivate

Get database string for frontier.

Definition at line 126 of file querying.py.

    def _cms_frontier_string(database, schema="cms_conditions"):
        """
        Get database string for frontier.
        """
        import urllib.request, urllib.parse, urllib.error
        return 'oracle+frontier://@%s/%s' % (urllib.parse.quote_plus(connection._get_CMS_frontier_connection_string(database)), schema)

_cms_oracle_string()

def querying.connection._cms_oracle_string (   user,   pwd,   db_name  )

staticprivate

Get database string for oracle.

Definition at line 134 of file querying.py.

    def _cms_oracle_string(user, pwd, db_name):
        """
        Get database string for oracle.
        """
        return 'oracle://%s:%s@%s' % (user, pwd, db_name)

_get_CMS_frontier_connection_string()

def querying.connection._get_CMS_frontier_connection_string (   database )

staticprivate

Definition at line 118 of file querying.py.

References communicate(), and nano_mu_digi_cff.strip.

    def _get_CMS_frontier_connection_string(database):
        try:
            import subprocess
            return subprocess.Popen(['cmsGetFnConnect', 'frontier://%s' % database], stdout = subprocess.PIPE).communicate()[0].strip()
        except:
            raise Exception("Frontier connections can only be constructed when inside a CMSSW environment.")

_oracle_match_format()

def querying.connection._oracle_match_format (   self,   string  )

private

Definition at line 228 of file querying.py.

Referenced by querying.connection.search_everything().

    def _oracle_match_format(self, string):
        return "%%%s%%" % string

build_frontier_url()

def querying.connection.build_frontier_url (   db_name,   schema  )

static

Definition at line 157 of file querying.py.

    def build_frontier_url(db_name, schema):
        database_url = connection._cms_frontier_string(db_name, schema)

        try:
            url = sqlalchemy.engine.url.make_url(database_url)
        except sqlalchemy.exc.ArgumentError:
            """
            Is this needed for a use case?
            """
            url = sqlalchemy.engine.url.make_url('sqlite:///%s' % db_name)
        return url

build_oracle_url()

def querying.connection.build_oracle_url (   user,   pwd,   db_name  )

static

Build the connection url, and get credentials from self.secrets dictionary.

Definition at line 141 of file querying.py.

    def build_oracle_url(user, pwd, db_name):
        """
        Build the connection url, and get credentials from self.secrets dictionary.
        """

        database_url = connection._cms_oracle_string(user, pwd, db_name)

        try:
            url = sqlalchemy.engine.url.make_url(database_url)
            if url.password is None:
                url.password = pwd
        except sqlalchemy.exc.ArgumentError:
            url = sqlalchemy.engine.url.make_url('sqlite:///%s' % db_name)
        return url

close_session()

def querying.connection.close_session

(

self

)

Definition at line 178 of file querying.py.

References querying.connection.session.

Referenced by querying.connection.tear_down().

    def close_session(self):
        self.session.close()
        return True

commit()

def querying.connection.commit

(

self

)

Definition at line 273 of file querying.py.

References querying.connection.rollback(), and querying.connection.session.

Referenced by querying.connection.tear_down(), and querying.connection.write_and_commit().

    def commit(self):
        try:
            self.session.commit()
        except:
            traceback.print_exc()
            self.session.rollback()

global_tag()

def querying.connection.global_tag	(		self,
			pkargs
	)

Definition at line 203 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def global_tag(self, **pkargs):
        return self.factory.object("globaltag", **pkargs)

global_tag_map()

def querying.connection.global_tag_map	(		self,
			pkargs
	)

Definition at line 206 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def global_tag_map(self, **pkargs):
        return self.factory.object("globaltagmap", **pkargs)

hard_close()

def querying.connection.hard_close

(

self

)

Definition at line 182 of file querying.py.

References cms::xerces.dispose(), and querying.connection.engine.

    def hard_close(self):
        self.engine.dispose()
        return True

iov()

def querying.connection.iov	(		self,
			pkargs
	)

Definition at line 218 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def iov(self, **pkargs):
        return self.factory.object("iov", **pkargs)

model()

def querying.connection.model	(		self,
			model_name
	)

Definition at line 187 of file querying.py.

References querying.connection.models.

Referenced by querying.connection.search_everything().

    def model(self, model_name):
        if model_name.__class__ == sqlalchemy.ext.declarative.api.DeclarativeMeta:
            model_name = model_name.__name__
        model_name = model_name.replace("_", "")
        return self.models[model_name]

object()

def querying.connection.object	(		self,
			model,
			pk_to_value
	)

Definition at line 195 of file querying.py.

References querying.connection.session.

Referenced by querying.connection.global_tag(), querying.connection.global_tag_map(), querying.connection.iov(), querying.connection.payload(), querying.connection.tag(), and querying.connection.tag_authorization().

    def object(self, model, pk_to_value):
        if self.session == None:
            return None
        model_data = self.session.query(model)
        for pk in pk_to_value:
            model_data = model_data.filter(model.__dict__[pk] == pk_to_value[pk])
        return model_data.first()

payload()

def querying.connection.payload	(		self,
			pkargs
	)

Definition at line 221 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def payload(self, **pkargs):
        return self.factory.object("payload", **pkargs)

rollback()

def querying.connection.rollback

(

self

)

Definition at line 289 of file querying.py.

References print(), and querying.connection.session.

Referenced by querying.connection.commit().

    def rollback(self):
        try:
            self.session.rollback()
        except:
            traceback.print_exc()
            print("Session couldn't be rolled back.")

search_everything()

def querying.connection.search_everything	(		self,
			string,
			amount = 10
	)

Definition at line 232 of file querying.py.

References querying.connection._oracle_match_format(), ALCARECOTkAlBeamHalo_cff.filter, remoteMonitoring_LASER_era2018_cfg.limit, TritonService::Module.model, L1TCaloSummary.model, querying.connection.model(), and querying.connection.session.

    def search_everything(self, string, amount=10):
        string = self._oracle_match_format(string)

        gt = self.model("globaltag")
        global_tags = self.session.query(gt).filter(or_(
                                                        gt.name.ilike(string),
                                                        gt.description.ilike(string),
                                                        gt.release.ilike(string)
                                                    )).limit(amount)
        tag = self.model("tag")
        tags = self.session.query(tag).filter(or_(
                                                    tag.name.ilike(string),
                                                    tag.object_type.ilike(string),
                                                    tag.description.ilike(string))
                                                ).limit(amount)
        iov = self.model("iov")
        iovs = self.session.query(iov).filter(or_(
                                                    iov.tag_name.ilike(string),
                                                    iov.since.ilike(string),
                                                    iov.payload_hash.ilike(string),
                                                    iov.insertion_time.ilike(string)
                                                )).limit(amount)
        payload = self.model("payload")
        payloads = self.session.query(payload).filter(or_(
                                                            payload.hash.ilike(string),
                                                            payload.object_type.ilike(string),
                                                            payload.insertion_time.ilike(string)
                                                        )).limit(amount)

        return json_data_node.make({
            "global_tags" : global_tags.all(),
            "tags" : tags.all(),
            "iovs" : iovs.all(),
            "payloads" : payloads.all()
        })

setup()

def querying.connection.setup

(

self

)

Setup engine with given credentials from netrc file, and make a session maker.

Definition at line 76 of file querying.py.

References querying.connection.connection_data.

Referenced by o2olib.O2OTool.execute().

    def setup(self):
        """
        Setup engine with given credentials from netrc file, and make a session maker.
        """

        if type(self.connection_data) == dict:
            self.engine = engine_from_dictionary(self.connection_data, pooling=self._pooling)
        else:
            # we've been given an engine by the user
            # use it as the engine
            self.engine = self.connection_data

        self.sessionmaker = sessionmaker(bind=self.engine)
        self.session = self.sessionmaker()
        self.factory = factory(self)

        # assign correct schema for database name to each model
        tmp_models_dict = {}
        for key in self.models:
            if self.models[key].__class__ == sqlalchemy.ext.declarative.api.DeclarativeMeta\
               and str(self.models[key].__name__) != "Base":

                if type(self.connection_data) == dict:
                    # we can only extract the secrets and schema individuall
                    # if we were given a dictionary...  if we were given an engine
                    # we can't do this without parsing the connection string from the engine
                    # - a wide range of which it will be difficult to support!
                    self.models[key].__table__.schema = self.connection_data["schema"]
                    self.models[key].secrets = self.connection_data["secrets"]

                self.models[key].session = self.session
                # isn't used anywhere - comment it out for now
                #self.models[key].authentication = self.netrc_authenticators
                self.models[key].connection = self
                tmp_models_dict[key.lower()] = self.models[key]
                tmp_models_dict[key.lower()].empty = False

        self.models = tmp_models_dict

        return self

tag()

def querying.connection.tag	(		self,
			pkargs
	)

Definition at line 212 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def tag(self, **pkargs):
        return self.factory.object("tag", **pkargs)

tag_authorization()

def querying.connection.tag_authorization	(		self,
			pkargs
	)

Definition at line 215 of file querying.py.

References querying.connection.factory, and querying.connection.object().

    def tag_authorization(self, **pkargs):
        return self.factory.object("tagauthorization", **pkargs)

tear_down()

def querying.connection.tear_down

(

self

)

Definition at line 171 of file querying.py.

References querying.connection.close_session(), querying.connection.commit(), querying.connection.engine, querying.connection.session, and str.

    def tear_down(self):
        try:
            self.session.commit()
            self.close_session()
        except:
            return "Couldn't tear down connection on engine %s." % str(self.engine)

write()

def querying.connection.write	(		self,
			object
	)

Definition at line 268 of file querying.py.

References PVValHelper.add(), querying.connection.schema, querying.connection.session, and models.session_independent_object().

Referenced by pkg.AbstractPkg.generate(), and querying.connection.write_and_commit().

    def write(self, object):
        new_object = models.session_independent_object(object, schema=self.schema)
        self.session.add(new_object)
        return new_object

write_and_commit()

def querying.connection.write_and_commit	(		self,
			object
	)

Definition at line 280 of file querying.py.

References cond::persistency::CondDBTransaction.commit(), cond::persistency::ITransaction.commit(), cond::persistency::Transaction.commit(), cond::persistency::TransactionScope.commit(), querying.connection.commit(), AlignmentCorrelationsIO.write(), AlignmentCorrelationsIORoot.write(), SurveyOutput.write(), AlignmentParametersIO.write(), popcon::PopConAnalyzer< S >.write(), AlignmentUserVariablesIO.write(), popcon::PopCon.write(), ProduceDropBoxMetadata.write, MuonAlignmentOutputXML.write(), XMLDOMBlock.write(), CSCPairResidualsConstraint.write(), presentation.SubsectionBase.write(), MuonResidualsTwoBin.write(), DTWorkflow.DTWorkflow.write(), XMLProcessor.write(), MuonResidualsFitter.write(), StraightTrackAlignment::RPSetPlots.write(), betterConfigParser.BetterConfigParser.write(), querying.connection.write(), and querying.connection.write_and_commit().

Referenced by querying.connection.write_and_commit().

    def write_and_commit(self, object):
        if type(object) == list:
            for item in object:
                self.write_and_commit(item)
        else:
            # should be changed to deal with errors - add them to exception handling if they appear
            self.write(object)
            self.commit()

Member Data Documentation

_pooling

querying.connection._pooling

private

Definition at line 37 of file querying.py.

connection_data

querying.connection.connection_data

Definition at line 49 of file querying.py.

Referenced by querying.connection.setup().

engine

querying.connection.engine

Definition at line 82 of file querying.py.

Referenced by o2o_db_manager.DbManager.connect(), querying.connection.hard_close(), conddblib.Connection.init(), conddblib.Connection.is_valid(), and querying.connection.tear_down().

factory

querying.connection.factory

Definition at line 90 of file querying.py.

Referenced by querying.connection.global_tag(), querying.connection.global_tag_map(), querying.connection.iov(), querying.connection.payload(), querying.connection.tag(), and querying.connection.tag_authorization().

models

querying.connection.models

Definition at line 73 of file querying.py.

Referenced by querying.connection.model().

radius

querying.connection.radius

Definition at line 43 of file querying.py.

range

querying.connection.range

Definition at line 42 of file querying.py.

regexp

querying.connection.regexp

Definition at line 44 of file querying.py.

schema

querying.connection.schema

Definition at line 50 of file querying.py.

Referenced by o2o_db_manager.DbManager.get_url(), and querying.connection.write().

session

querying.connection.session

Definition at line 89 of file querying.py.

Referenced by o2olib.O2OJobMgr.add(), querying.connection.close_session(), querying.connection.commit(), o2olib.O2OJobMgr.dumpConfig(), o2olib.O2ORunMgr.endJob(), o2olib.O2OJobMgr.listConfig(), o2olib.O2OJobMgr.listJobs(), querying.connection.object(), querying.connection.rollback(), o2olib.O2OJobMgr.runManager(), querying.connection.search_everything(), o2olib.O2OJobMgr.set(), o2olib.O2OJobMgr.setConfig(), o2olib.O2OJobMgr.setInterval(), o2olib.O2ORunMgr.startJob(), querying.connection.tear_down(), and querying.connection.write().

sessionmaker

querying.connection.sessionmaker

Definition at line 88 of file querying.py.