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	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 25 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 37 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, unicode]:
            # 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 128 of file querying.py.

    def _cms_frontier_string(database, schema="cms_conditions"):
        """
        Get database string for frontier.
        """
        import urllib
        return 'oracle+frontier://@%s/%s' % (urllib.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 136 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 120 of file querying.py.

    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.")
 

References communicate(), and digitizers_cfi.strip.

_oracle_match_format()

def querying.connection._oracle_match_format (   self,   string  )

private

Definition at line 227 of file querying.py.

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

Referenced by querying.connection.search_everything().

build_frontier_url()

def querying.connection.build_frontier_url (   db_name,   schema  )

static

Definition at line 159 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 143 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 180 of file querying.py.

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

References querying.connection.session.

Referenced by querying.connection.tear_down().

commit()

def querying.connection.commit

(

self

)

Definition at line 272 of file querying.py.

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

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

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

global_tag()

def querying.connection.global_tag	(		self,
		**	pkargs
	)

Definition at line 205 of file querying.py.

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

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

global_tag_map()

def querying.connection.global_tag_map	(		self,
		**	pkargs
	)

Definition at line 208 of file querying.py.

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

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

hard_close()

def querying.connection.hard_close

(

self

)

Definition at line 184 of file querying.py.

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

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

iov()

def querying.connection.iov	(		self,
		**	pkargs
	)

Definition at line 217 of file querying.py.

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

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

model()

def querying.connection.model	(		self,
			model_name
	)

Definition at line 189 of file querying.py.

    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]
 

References querying.connection.models.

Referenced by querying.connection.search_everything().

object()

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

Definition at line 197 of file querying.py.

    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()
 

References querying.connection.session.

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

payload()

def querying.connection.payload	(		self,
		**	pkargs
	)

Definition at line 220 of file querying.py.

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

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

rollback()

def querying.connection.rollback

(

self

)

Definition at line 288 of file querying.py.

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

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

Referenced by querying.connection.commit().

search_everything()

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

Definition at line 231 of file querying.py.

    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()
        })
 

References querying.connection._oracle_match_format(), ALCARECOTkAlBeamHalo_cff.filter, remoteMonitoring_LED_IterMethod_cfg.limit, querying.connection.model(), and querying.connection.session.

setup()

def querying.connection.setup

(

self

)

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

Definition at line 78 of file querying.py.

    def setup(self):
        """
        Setup engine with given credentials from netrc file, and make a session maker.
        """
 
        if isinstance(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 isinstance(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
 

References querying.connection.connection_data.

Referenced by o2olib.O2OTool.execute().

tag()

def querying.connection.tag	(		self,
		**	pkargs
	)

Definition at line 214 of file querying.py.

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

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

tear_down()

def querying.connection.tear_down

(

self

)

Definition at line 173 of file querying.py.

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

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

write()

def querying.connection.write	(		self,
			object
	)

Definition at line 267 of file querying.py.

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

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().

write_and_commit()

def querying.connection.write_and_commit	(		self,
			object
	)

Definition at line 279 of file querying.py.

    def write_and_commit(self, object):
        if isinstance(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()
 

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

Referenced by querying.connection.write_and_commit().

Member Data Documentation

_pooling

querying.connection._pooling

private

Definition at line 39 of file querying.py.

connection_data

querying.connection.connection_data

Definition at line 51 of file querying.py.

Referenced by querying.connection.setup().

engine

querying.connection.engine

Definition at line 84 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 92 of file querying.py.

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

models

querying.connection.models

Definition at line 75 of file querying.py.

Referenced by querying.connection.model().

radius

querying.connection.radius

Definition at line 45 of file querying.py.

range

querying.connection.range

Definition at line 44 of file querying.py.

regexp

querying.connection.regexp

Definition at line 46 of file querying.py.

schema

querying.connection.schema

Definition at line 52 of file querying.py.

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

session

querying.connection.session

Definition at line 91 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(), o2olib.O2OJobMgr.migrateConfig(), 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 90 of file querying.py.