[Zope-dev] Re: SQLAlchemy integration experiment

[Martijn Faassen]

Hi there,

Just as some context: I'm not proposing to extend zope.sqlalchemy at
all. I'm proposing to write an extension that has the configuration
pattern I sketched out. I also don't intend to write the last
SQLAlchemy integration layer; I wouldn't be so presumptious. :) That
said, if we can come up with something we all feel comfortable with,
hopefully the configuration package will be used by others as well.

On Tue, Jun 17, 2008 at 3:36 PM, Brian Sutherland
<brian at vanguardistas.net> wrote:
[snip]
> Hmm, how about this approach. It builds on and is almost compatible
> with yours, but allows me a plug in point where I need it. My use case
> is the simplest in that I have no local utilities and no need of
> application scoped sessions (plain old thread scoping works just fine).
>
> But I would like to have the option of using code others write for
> zope/sqlalchemy and allow others to use our code.
>
> The total code I would write in zope.sqlalchemy would be this:
>
>    class ISession(Interface):
>
>        def __call__():
>            """Return a SQLAlchemy Session object"""
>
>    def Session():
>        return getUtility(ISession)()
>
> I would use it in view code like:
>
>    from zope.sqlalchemy import Session
>
>    class View:
>
>        def some_view_method(self):
>            session = Session()
>            session.do_stuff()
>
> I do believe that the application scoping approach you showed us could
> be implemented by registering your session as the ISession utility.

I'm not sure it makes sense to add an extra utility lookup each time I
get a session. Right now the scoped session just gets the thing if
it's already cached, and there's already a local utility lookup to get
the scope UID.

What about this?

class IDatabase(Interface):
    def scopefunc():
          """The scopefunc"""

    def session_factory():
          """The session factory"""

def scopefunc():
     util = component.getUtility(IDatabase)
     return util.scopefunc()

This will allow you to implement a global IDatabase utility that's
global and uses a thread-local scope only.
Similarly, we can delegate session creation to the IDatabase utility completely:

def session_factory():
   util = component.getUtility(IDatabase)
   return util.session_factory()

I think that's better than what I have now, as you can then completely
control session creation through a utility. It doesn't add a new
plugin point or utility lookup, but allows you to implement your use
case, right? We'll just need to implement a number of utilities that
fulfill the various use cases.

Regards,

Martijn