def __init__(self, dsn, model=None, transactional=True, twophase=False, engine_options={}, session_options={}, extension_options={}, **kw): """ 'dsn' - a RFC-1738-style connection string 'model' - optional instance of model.Model 'engine_options' - optional keyword arguments passed to create_engine() 'session_options' - optional keyword arguments passed to create_session() or sessionmaker() 'extension_options' - optional keyword argument passed to ZopeTransactionExtension() 'transactional' - True|False, only used by SQLAlchemyDA, *don't touch it* """ self.dsn = dsn self.url = make_url(dsn) self.host = self.url.host self.port = self.url.port self.username = self.url.username self.password = self.url.password self.dbname = self.url.database self.twophase = twophase self.drivername = self.url.drivername self.transactional = transactional self.engine_options = engine_options if 'echo' in kw: self.engine_options.update(echo=kw['echo']) self.session_options = session_options self.extension_options = extension_options self._model = None self._createEngine() if model: if isinstance(model, Model): self._model = model elif isinstance(model, str): try: util = getUtility(IModelProvider, model) except ComponentLookupError: raise ComponentLookupError("No named utility '%s' providing IModelProvider found" % model) self._model = util.getModel(self.metadata) elif callable(model): self._model = model(self.metadata) else: raise ValueError("The 'model' parameter passed to constructor must either be " "the name of a named utility implementing IModelProvider or " "an instance of z3c.sqlalchemy.model.Model.") if not isinstance(self._model, Model): raise TypeError('_model is not an instance of model.Model') # mappers must be initialized at last since we need to acces # the 'model' from within the constructor of LazyMapperCollection self._mappers = LazyMapperCollection(self)
def __init__(self, dsn, model=None, transactional=True, twophase=False, engine_options={}, session_options={}, extension_options={}, **kw): """ 'dsn' - a RFC-1738-style connection string 'model' - optional instance of model.Model 'engine_options' - optional keyword arguments passed to create_engine() 'session_options' - optional keyword arguments passed to create_session() or sessionmaker() 'extension_options' - optional keyword argument passed to ZopeTransactionExtension() 'transactional' - True|False, only used by SQLAlchemyDA, *don't touch it* """ self.dsn = dsn self.url = make_url(dsn) self.host = self.url.host self.port = self.url.port self.username = self.url.username self.password = self.url.password self.dbname = self.url.database self.twophase = twophase self.drivername = self.url.drivername self.transactional = transactional self.engine_options = engine_options if 'echo' in kw: self.engine_options.update(echo=kw['echo']) self.session_options = session_options self.extension_options = extension_options self._model = None self._createEngine() if model: if isinstance(model, Model): self._model = model elif isinstance(model, basestring): try: util = getUtility(IModelProvider, model) except ComponentLookupError: raise ComponentLookupError("No named utility '%s' providing IModelProvider found" % model) self._model = util.getModel(self.metadata) elif callable(model): self._model = model(self.metadata) else: raise ValueError("The 'model' parameter passed to constructor must either be " "the name of a named utility implementing IModelProvider or " "an instance of z3c.sqlalchemy.model.Model.") if not isinstance(self._model, Model): raise TypeError('_model is not an instance of model.Model') # mappers must be initialized at last since we need to acces # the 'model' from within the constructor of LazyMapperCollection self._mappers = LazyMapperCollection(self)
class ZopeWrapper(object): def __init__(self, dsn, model=None, transactional=True, twophase=False, engine_options={}, session_options={}, extension_options={}, **kw): """ 'dsn' - a RFC-1738-style connection string 'model' - optional instance of model.Model 'engine_options' - optional keyword arguments passed to create_engine() 'session_options' - optional keyword arguments passed to create_session() or sessionmaker() 'extension_options' - optional keyword argument passed to ZopeTransactionExtension() 'transactional' - True|False, only used by SQLAlchemyDA, *don't touch it* """ self.dsn = dsn self.url = make_url(dsn) self.host = self.url.host self.port = self.url.port self.username = self.url.username self.password = self.url.password self.dbname = self.url.database self.twophase = twophase self.drivername = self.url.drivername self.transactional = transactional self.engine_options = engine_options if 'echo' in kw: self.engine_options.update(echo=kw['echo']) self.session_options = session_options self.extension_options = extension_options self._model = None self._createEngine() if model: if isinstance(model, Model): self._model = model elif isinstance(model, str): try: util = getUtility(IModelProvider, model) except ComponentLookupError: raise ComponentLookupError("No named utility '%s' providing IModelProvider found" % model) self._model = util.getModel(self.metadata) elif callable(model): self._model = model(self.metadata) else: raise ValueError("The 'model' parameter passed to constructor must either be " "the name of a named utility implementing IModelProvider or " "an instance of z3c.sqlalchemy.model.Model.") if not isinstance(self._model, Model): raise TypeError('_model is not an instance of model.Model') # mappers must be initialized at last since we need to acces # the 'model' from within the constructor of LazyMapperCollection self._mappers = LazyMapperCollection(self) @property def metadata(self): if not hasattr(self, '_v_metadata'): self._v_metadata = MetaData(self._engine) return self._v_metadata @property def session(self): """ Return thread-local session """ return self._sessionmaker() @property def connection(self): """ Return underlying connection """ session = self.session # Return the ConnectionFairy return session.connection().connection # instead of the raw connection #return session.connection().connection.connection def registerMapper(self, mapper, name): self._mappers._registerMapper(mapper, name) def getMapper(self, tablename, schema='public'): return self._mappers.getMapper(tablename, schema) def getMappers(self, *names): return tuple([self.getMapper(name) for name in names]) @property def engine(self): """ only for private purposes! """ return self._engine @property def model(self): """ only for private purposes! """ return self._model def _createEngine(self): self._engine = create_engine(self.dsn, **self.engine_options) self._sessionmaker = scoped_session(sessionmaker(bind=self._engine, autocommit=not self.transactional, twophase=self.twophase, autoflush=True, extension=ZopeTransactionExtension(**self.extension_options), **self.session_options))
class ZopeWrapper(object): implements(ISQLAlchemyWrapper) def __init__(self, dsn, model=None, transactional=True, twophase=False, engine_options={}, session_options={}, extension_options={}, **kw): """ 'dsn' - a RFC-1738-style connection string 'model' - optional instance of model.Model 'engine_options' - optional keyword arguments passed to create_engine() 'session_options' - optional keyword arguments passed to create_session() or sessionmaker() 'extension_options' - optional keyword argument passed to ZopeTransactionExtension() 'transactional' - True|False, only used by SQLAlchemyDA, *don't touch it* """ self.dsn = dsn self.url = make_url(dsn) self.host = self.url.host self.port = self.url.port self.username = self.url.username self.password = self.url.password self.dbname = self.url.database self.twophase = twophase self.drivername = self.url.drivername self.transactional = transactional self.engine_options = engine_options if 'echo' in kw: self.engine_options.update(echo=kw['echo']) self.session_options = session_options self.extension_options = extension_options self._model = None self._createEngine() if model: if isinstance(model, Model): self._model = model elif isinstance(model, basestring): try: util = getUtility(IModelProvider, model) except ComponentLookupError: raise ComponentLookupError("No named utility '%s' providing IModelProvider found" % model) self._model = util.getModel(self.metadata) elif callable(model): self._model = model(self.metadata) else: raise ValueError("The 'model' parameter passed to constructor must either be " "the name of a named utility implementing IModelProvider or " "an instance of z3c.sqlalchemy.model.Model.") if not isinstance(self._model, Model): raise TypeError('_model is not an instance of model.Model') # mappers must be initialized at last since we need to acces # the 'model' from within the constructor of LazyMapperCollection self._mappers = LazyMapperCollection(self) @property def metadata(self): if not hasattr(self, '_v_metadata'): self._v_metadata = MetaData(self._engine) return self._v_metadata @property def session(self): """ Return thread-local session """ return self._sessionmaker() @property def connection(self): """ Return underlying connection """ session = self.session # Return the ConnectionFairy return session.connection().connection # instead of the raw connection #return session.connection().connection.connection def registerMapper(self, mapper, name): self._mappers._registerMapper(mapper, name) def getMapper(self, tablename, schema='public'): return self._mappers.getMapper(tablename, schema) def getMappers(self, *names): return tuple([self.getMapper(name) for name in names]) @property def engine(self): """ only for private purposes! """ return self._engine @property def model(self): """ only for private purposes! """ return self._model def _createEngine(self): self._engine = create_engine(self.dsn, **self.engine_options) self._sessionmaker = scoped_session(sessionmaker(bind=self._engine, autocommit=not self.transactional, twophase=self.twophase, autoflush=True, extension=ZopeTransactionExtension(**self.extension_options), **self.session_options))