Inheritance diagram for conddblib.Connection:

Public Member Functions
def	__init__ (self, url)

def	get_dbtype (self, theType)

def	init (self, drop=False)

def	is_frontier (self)

def	is_official (self)

def	is_oracle (self)

def	is_read_only (self)

def	is_sqlite (self)

def	is_valid (self)

def	metadata (self)

def	session (self)

Public Attributes
	engine

Private Attributes
	_backendName

	_is_frontier

	_is_official

	_is_oracle

	_is_read_only

	_is_sqlite

	_is_valid

	_schemaName

	_session

	_url

Detailed Description

Definition at line 321 of file conddblib.py.

Constructor & Destructor Documentation

def conddblib.Connection.__init__	(	self,
		url
	)

Definition at line 323 of file conddblib.py.

     def __init__(self, url):
         # Workaround to avoid creating files if not present.
         # Python's sqlite3 module does not use sqlite3_open_v2(),
         # and therefore we cannot disable SQLITE_OPEN_CREATE.
         # Only in the case of creating a new database we skip the check.
         if url.drivername == 'sqlite':
 
             self.engine = sqlalchemy.create_engine(url)
 
             enabled_foreign_keys = self.engine.execute('pragma foreign_keys').scalar()
             supports_foreign_keys = enabled_foreign_keys is not None
             if not supports_foreign_keys:
                 logger.warning('Your SQLite database does not support foreign keys, so constraints will not be checked. Please upgrade.')
             elif not enabled_foreign_keys:
                 self.engine.execute('pragma foreign_keys = on')
 
         else:
             self.engine = sqlalchemy.create_engine(url)
 
         self._session = sqlalchemy.orm.scoped_session(sqlalchemy.orm.sessionmaker(bind=self.engine))
 
         self._is_frontier = url.drivername == 'oracle+frontier'
         self._is_oracle = url.drivername == 'oracle'
         self._is_sqlite = url.drivername == 'sqlite'
 
         self._is_read_only = self._is_frontier or url.host in {
             'cms_orcon_adg',
             'cmsarc_lb',
         }
 
         self._is_official = self._is_frontier or url.host in {
             'cms_orcon_adg',
             'cmsarc_lb',
             'cms_orcoff_int',
             'cms_orcoff_prep',
             'cms_orcon_prod',
             'cmsintr_lb',
         }
         self._url = url
         self._backendName = ('sqlite' if self._is_sqlite else 'oracle' ) 
         self._schemaName = ( None if self._is_sqlite else schema_name )
         logging.debug(' ... using db "%s", schema "%s"' % (url, self._schemaName) )
         logging.debug('Loading db types...')
         self.get_dbtype(Tag).__name__
         self.get_dbtype(Payload)
         self.get_dbtype(IOV)
         self.get_dbtype(TagLog)
         self.get_dbtype(GlobalTag)
         self.get_dbtype(GlobalTagMap)
         self.get_dbtype(RunInfo)
         self._is_valid = self.is_valid()
 

Member Function Documentation

def conddblib.Connection.get_dbtype	(	self,
		theType
	)

Definition at line 375 of file conddblib.py.

References conddblib.Connection._backendName, conddblib.Connection._schemaName, relativeConstraints.keys, and conddblib.make_dbtype().

Referenced by conddblib.Connection.init(), conddblib.Connection.is_valid(), and conddblib.Connection.session().

     def get_dbtype(self,theType):
         basename = theType.__name__
         if self._backendName not in db_models.keys() or basename not in db_models[self._backendName].keys():
             return make_dbtype( self._backendName, self._schemaName, theType )
         else:
             return db_models[self._backendName][basename]
 

def conddblib.Connection.init	(	self,
		drop = `False`
	)

Initializes a database.

Definition at line 425 of file conddblib.py.

References conddblib.Connection._is_valid, querying.connection.engine, conddblib.Connection.engine, and conddblib.Connection.get_dbtype().

     def init(self, drop=False):
         '''Initializes a database.
         '''
         logging.info('Initializing database...')
         if drop:
             logging.debug('Dropping tables...')
             self.metadata.drop_all(self.engine)
             self._is_valid = False
         else:
             if not self._is_valid:
                 logging.debug('Creating tables...')
                 self.get_dbtype(Tag).__table__.create(bind = self.engine)
                 self.get_dbtype(Payload).__table__.create(bind = self.engine)
                 self.get_dbtype(IOV).__table__.create(bind = self.engine)
                 self.get_dbtype(TagLog).__table__.create(bind = self.engine)
                 self.get_dbtype(GlobalTag).__table__.create(bind = self.engine)
                 self.get_dbtype(GlobalTagMap).__table__.create(bind = self.engine)
                 self._is_valid = True
 

def conddblib.Connection.is_frontier ( self )

Definition at line 394 of file conddblib.py.

References conddblib.Connection._is_frontier.

     def is_frontier(self):
         return self._is_frontier
 

def conddblib.Connection.is_official ( self )

Definition at line 410 of file conddblib.py.

References conddblib.Connection._is_official.

     def is_official(self):
         return self._is_official
 

def conddblib.Connection.is_oracle ( self )

Definition at line 398 of file conddblib.py.

References conddblib.Connection._is_oracle.

     def is_oracle(self):
         return self._is_oracle
 

def conddblib.Connection.is_read_only ( self )

Definition at line 406 of file conddblib.py.

References conddblib.Connection._is_read_only.

     def is_read_only(self):
         return self._is_read_only
 

def conddblib.Connection.is_sqlite ( self )

Definition at line 402 of file conddblib.py.

References conddblib.Connection._is_sqlite.

     def is_sqlite(self):
         return self._is_sqlite
 

def conddblib.Connection.is_valid ( self )

Tests whether the current DB looks like a valid CMS Conditions one.

Definition at line 413 of file conddblib.py.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor.all(), conddblib.Connection.get_dbtype(), and conddblib.getSchema().

     def is_valid(self):
         '''Tests whether the current DB looks like a valid CMS Conditions one.
         '''
         engine_connection = self.engine.connect()
         # temporarely avoid the check on the GT tables - there are releases in use where C++ does not create these tables.
         _Tag = self.get_dbtype(Tag)
         _IOV = self.get_dbtype(IOV)
         _Payload = self.get_dbtype(Payload) 
         ret = all([self.engine.dialect.has_table(engine_connection, table.__tablename__,getSchema(table)) for table in [_Tag, _IOV, _Payload]])
         engine_connection.close()
         return ret
 

def conddblib.Connection.metadata ( self )

Definition at line 390 of file conddblib.py.

     def metadata(self):
         return _Base.metadata
 

def conddblib.Connection.session ( self )

Definition at line 382 of file conddblib.py.

References conddblib.Connection._is_sqlite, conddblib.Connection._session, url_query.url_query._url, conddblib.Connection._url, and conddblib.Connection.get_dbtype().

     def session(self):
         s = self._session()
         s.get_dbtype = self.get_dbtype
         s._is_sqlite = self._is_sqlite
         s._url = self._url
         return s
 