[Grok-dev] Modeling a class that extend from list() with megrok.rdb

Hector Blanco white.lists at gmail.com
Tue Oct 26 17:16:22 EDT 2010

Hi guys!

Thank you for your answers.

To Jeff Petterson>
     That's doable, but I would like to avoid (if possible) creating
raw MySQL queries. It turns out I am working with a pre-existent code,
and the system doesn't really uses raw queries. It relies on
sqlalchemy + megrok.rdb and I'd like to keep it consistent (once
again, if possible). I have worked in other projects and I always
prefer going to the lowest level possible (SQL queries "by hand")
because I feel I can control them better, but not in this occasion.

To Santiago Videla>
     I took a look to the containers, but they seem to me just
intermediate tables to define relationships, correct? Well... once
again, I have to deal with the pre-existing code. The guys that
developed it didn't use containers classes. The tables that were used
as intermediate tables to specify relationships where declared in a
lower level (only with sqlalchemy commands). To keep consistency with
the existing code, I'd like to be able to define that intermediate
tables myself.

As I mentioned, the way I have it now is:

class MyEntry(object):
       def __init__(self):
               self.field1 = “field1”
               self.field2 = “field2”

class MyContainer(list):
       def __init__(self):

       def append(myEntry):
               if isinstance(myEntry, MyEntry):
                       super(MyContainer, self).append(myEntry)

       def getByField1(self, field1):
               for element in self:
                       if element.field1 == field1:
                               return element
               return None

       [ ... more useful methods ...]

class MyClass(object):
       def __init__(self):
               self.container1 = MyContainer()
               self.container2 = MyContainer()
               self.anotherField = “hello world”
       def getContainer1():
               return self.container1
       def getContainer2():
               return self.container2

I see clearly the "MyEntry" and "MyClass" classes descending from
(rdb.Model). I also see clearly the intermediate table for

#This would be the equivalent to a "rdb.Container", correct, Mr.
Videla? Well... in the current system, it is done "by hand", like
my_containers_table = Table(
	Column("id", Integer,  primary_key=True),
	Column("my_entry_id", Integer, ForeignKey("my_entries_table.id"))

but I don't know how to link the MyContainer(list) object with
my_containers_table (and from there with MyClass) :-(

I guess MyClass could be modeled with something like:

class MyClass(rdb.Model):
	id = Column("id", Integer, primary_key=True)
	anotherField =  Column("another_field", String(16))
	container1 = Column("container_1", Integer,
	container2 = Column("container_2", Integer,

But now, how do I establish the relationship between
MyClass.container1 or MyClass.container2 with "my_containers_table"?
On one hand, I want MyClass.container1 and MyClass.container2 to be
foreign keys, but on the other, I want them to be instances of
MyContainer(list)... And that's where I start banging my head on the
wall :-)

I know... the existing code is a complicated mix between megrok and
sqlalchemy... but that's what I have to deal with (although if it
needs to be changed because there's no other way, well... I can do it)

Thank you again

2010/10/26 Santiago Videla <santiago.videla at gmail.com>:
> Hi, I am not working with megrok.rdb these days neither with grok... but,
> did you see rdb.Container and rdb.QueryContainer? I am not sure, but maybe
> it could help you with this.
> Regards,
> On Mon, Oct 25, 2010 at 7:02 PM, Hector Blanco <white.lists at gmail.com>
> wrote:
>> Hi list!
>> I am trying to migrate my application from ZopeDB to MySql. I am using
>> megrok.rdb.
>> I have a class which inherits from list() and has a few extra methods.
>> That class acts as a container of other classes and is used (as an
>> attribute) in other classes as well:
>> class MyEntry(object):
>>        def __init__(self):
>>                self.field1 = “field1”
>>                self.field2 = “field2”
>> class MyContainer(list):
>>        def __init__(self):
>>                super(MyContainer,self).__init__()
>>        def append(myEntry):
>>                if isinstance(myEntry, MyEntry):
>>                        super(MyContainer, self).append(myEntry)
>>        def getByField1(self, field1):
>>                for element in self:
>>                        if element.field1 == field1:
>>                                return element
>>                return None
>>        [ ... more useful methods ...]
>> class MyClass(object):
>>        def __init__(self):
>>                self.container1 = MyContainer()
>>                self.container2 = MyContainer()
>>                self.anotherField = “hello world”
>>        def getContainer1():
>>                return self.container1
>>        def getContainer2():
>>                return self.container2
>> I don't really know how to model this with megrok.rdb. I kind of see
>> clearly (although I may be totally wrong) that MyEntry and MyClass
>> should extend from rdb.Model and each of them should be stored in a
>> table, but I don't really know what to do with “MyContainer”. I'd like
>> to keep it inheriting from list, but I don't know how to model that.
>> It really only needs to be an association between [id, id_of_my_entry]
>> (relationship 1:N). In MyClass, each of the containers would get an id
>> and then, if I want to get the “MyEntries” that are in container1, I
>> just need to get the MyEntries who are linked to that id.
>> … but I have no idea about how to implement that... Any hint I could
>> get would be deeply appreciated.
>> Thank you in advance!
>> _______________________________________________
>> Grok-dev mailing list
>> Grok-dev at zope.org
>> https://mail.zope.org/mailman/listinfo/grok-dev
> --
> Santiago Videla
> http://www.linkedin.com/in/svidela
> Sigue la mata dando de que hablar siempre abajo y a la izquierda donde el
> pensamiento que se hace corazón resplandece con la palabra sencilla y
> humilde que l at s tod at s somos.

More information about the Grok-dev mailing list