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 23 of file querying.py.

Constructor & Destructor Documentation

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, 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
 
         import models as ms
         self.models = ms.generate(map_blobs)
         #self.base = self.models["Base"]
 

Member Function Documentation

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
         return 'oracle+frontier://@%s/%s' % (urllib.quote_plus(connection._get_CMS_frontier_connection_string(database)), schema)
 

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)
 

def querying.connection._get_CMS_frontier_connection_string ( database )

staticprivate

Definition at line 118 of file querying.py.

References communicate(), and digitizers_cfi.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.")
 

def querying.connection._oracle_match_format	(	self,
		string
	)

private

Definition at line 225 of file querying.py.

Referenced by querying.connection.search_everything().

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

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
 

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
 

def querying.connection.close_session ( self )

Definition at line 178 of file querying.py.

Referenced by querying.connection.tear_down().

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

def querying.connection.commit ( self )

Definition at line 270 of file querying.py.

Referenced by querying.connection.write_and_commit().

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

def querying.connection.global_tag	(	self,
		pkargs
	)

Definition at line 203 of file querying.py.

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

def querying.connection.global_tag_map	(	self,
		pkargs
	)

Definition at line 206 of file querying.py.

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

def querying.connection.hard_close ( self )

Definition at line 182 of file querying.py.

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

def querying.connection.iov	(	self,
		pkargs
	)

Definition at line 215 of file querying.py.

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

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(), Vispa.Gui.Header.Header.setText(), and Vispa.Gui.SimpleDraggableTreeWidget.SimpleDraggableTreeWidget.startDrag().

     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]
 

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

Definition at line 195 of file querying.py.

References querying.connection.session.

Referenced by Vispa.Views.LineDecayView.LineDecayContainer.createObject(), Vispa.Views.LineDecayView.LineDecayContainer.delete(), Vispa.Views.LineDecayView.DecayLine.delete(), Vispa.Views.LineDecayView.LineDecayContainer.mouseReleaseEvent(), and Vispa.Views.BoxDecayView.BoxDecayContainer.toggleCollapse().

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

def querying.connection.payload	(	self,
		pkargs
	)

Definition at line 218 of file querying.py.

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

def querying.connection.rollback ( self )

Definition at line 286 of file querying.py.

References edm.print().

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

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

Definition at line 229 of file querying.py.

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

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

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

def querying.connection.tag	(	self,
		pkargs
	)

Definition at line 212 of file querying.py.

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

def querying.connection.tear_down ( self )

Definition at line 171 of file querying.py.

References querying.connection.close_session(), querying.connection.engine, 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)
 

def querying.connection.write	(	self,
		object
	)

Definition at line 265 of file querying.py.

References querying.connection.schema, 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
 

def querying.connection.write_and_commit	(	self,
		object
	)

Definition at line 277 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(), pos::PixelConfig.write(), AlignmentCorrelationsIORoot.write(), SurveyOutput.write(), AlignmentParametersIO.write(), AlignmentUserVariablesIO.write(), popcon::PopConAnalyzer< S >.write(), popcon::PopCon.write(), MuonAlignmentOutputXML.write(), CSCPairResidualsConstraint.write(), XMLDOMBlock.write(), XMLDocument.write, MuonResidualsTwoBin.write(), presentation.SubsectionBase.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().

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