Thread: [SQLObject] alternateID and notNone=False
SQLObject is a Python ORM.
Brought to you by:
ianbicking,
phd
From: Jason P. <ce...@ic...> - 2005-10-19 16:33:37
|
Hi, Is there a compelling reason to have alternateID imply notNone? There are situations where a peice of information, say a serial number, isn't always available but it would still be nice to have a bySerial() function which operates over those items for which you do have a serial number. I would like to do this: --- cut --- #!/usr/bin/python from sqlobject import * class Foo(SQLObject): name = StringCol(alternateID=True) serial = StringCol(alternateID=True, notNone=False, default=None) if __name__ == "__main__": sqlhub.processConnection = connectionForURI('sqlite:/:memory:') Foo.createTable() foo1 = Foo(name="bob") foo2 = Foo(name="joe", serial="42") print Foo.byName("bob") print Foo.bySerial("42") --- cut --- but instead I have to do this, which isn't quite as pretty: --- cut --- #!/usr/bin/python from sqlobject import * # black magic for static methods. # see http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52304 class Callable: def __init__(self, anycallable): self.__call__ = anycallable class Foo(SQLObject): name = StringCol(alternateID=True) serial = StringCol(unique=True, notNone=False, default=None) def bySerial(serial): for foo in Foo.select(): if foo.serial != None and foo.serial == serial: return foo raise SQLObjectNotFound, "The %s identified by serial=%s does not exist" % (Foo.__name__, repr(serial)) bySerial = Callable(bySerial) if __name__ == "__main__": sqlhub.processConnection = connectionForURI('sqlite:/:memory:') Foo.createTable() foo1 = Foo(name="bob") foo2 = Foo(name="joe", serial="42") print Foo.byName("bob") print Foo.bySerial("42") --- cut --- |
From: Rick F. <rf...@im...> - 2005-10-19 16:44:06
|
an alternateID means that the column is unique. if you have multiple columns with NULL values then that column is no longer unique. I think you should be able to write your own bySerial() method on your class. -- rick On Wed, 19 Oct 2005, Jason Pepas wrote: > Hi, > > Is there a compelling reason to have alternateID imply notNone? > > There are situations where a peice of information, say a serial number, > isn't always available but it would still be nice to have a bySerial() > function which operates over those items for which you do have a serial > number. > > I would like to do this: > > --- cut --- > #!/usr/bin/python > > from sqlobject import * > > class Foo(SQLObject): > name = StringCol(alternateID=True) > serial = StringCol(alternateID=True, notNone=False, default=None) > > if __name__ == "__main__": > sqlhub.processConnection = connectionForURI('sqlite:/:memory:') > Foo.createTable() > > foo1 = Foo(name="bob") > foo2 = Foo(name="joe", serial="42") > > print Foo.byName("bob") > print Foo.bySerial("42") > --- cut --- > > but instead I have to do this, which isn't quite as pretty: > > --- cut --- > #!/usr/bin/python > > from sqlobject import * > > # black magic for static methods. > # see http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52304 > class Callable: > def __init__(self, anycallable): > self.__call__ = anycallable > > class Foo(SQLObject): > name = StringCol(alternateID=True) > serial = StringCol(unique=True, notNone=False, default=None) > > def bySerial(serial): > for foo in Foo.select(): > if foo.serial != None and foo.serial == serial: > return foo > raise SQLObjectNotFound, "The %s identified by serial=%s does not exist" % (Foo.__name__, repr(serial)) > bySerial = Callable(bySerial) > > > if __name__ == "__main__": > sqlhub.processConnection = connectionForURI('sqlite:/:memory:') > Foo.createTable() > > foo1 = Foo(name="bob") > foo2 = Foo(name="joe", serial="42") > > print Foo.byName("bob") > print Foo.bySerial("42") > --- cut --- > > > > ------------------------------------------------------- > This SF.Net email is sponsored by: > Power Architecture Resource Center: Free content, downloads, discussions, > and more. http://solutions.newsforge.com/ibmarch.tmpl > _______________________________________________ > sqlobject-discuss mailing list > sql...@li... > https://lists.sourceforge.net/lists/listinfo/sqlobject-discuss > |
From: Jason P. <ce...@ic...> - 2005-10-19 17:14:18
|
On Wed, Oct 19, 2005 at 11:44:01AM -0500, Rick Flosi wrote: > an alternateID means that the column is unique. > if you have multiple columns with NULL values then that column is no > longer unique. That is incorrect. Note in my example below: StringCol(unique=True, notNone=False, default=None) > I think you should be able to write your own bySerial() method on your > class. This is just what I have done below. The question I am facing now is this: If you can have unique=True *and* notNone=False in the same column, what good reason is there for alternateID to assert that notNone=True? Perhaps I should dive in and work up a patch which will allow the user to override the default behavior of alternateID like so: StringCol(alternateID=True, notNone=False) -jason pepas > On Wed, 19 Oct 2005, Jason Pepas wrote: > > >Hi, > > > >Is there a compelling reason to have alternateID imply notNone? > > > >There are situations where a peice of information, say a serial number, > >isn't always available but it would still be nice to have a bySerial() > >function which operates over those items for which you do have a serial > >number. > > > >I would like to do this: > > > >--- cut --- > >#!/usr/bin/python > > > >from sqlobject import * > > > >class Foo(SQLObject): > > name = StringCol(alternateID=True) > > serial = StringCol(alternateID=True, notNone=False, default=None) > > > >if __name__ == "__main__": > > sqlhub.processConnection = connectionForURI('sqlite:/:memory:') > > Foo.createTable() > > > > foo1 = Foo(name="bob") > > foo2 = Foo(name="joe", serial="42") > > > > print Foo.byName("bob") > > print Foo.bySerial("42") > >--- cut --- > > > >but instead I have to do this, which isn't quite as pretty: > > > >--- cut --- > >#!/usr/bin/python > > > >from sqlobject import * > > > ># black magic for static methods. > ># see http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52304 > >class Callable: > > def __init__(self, anycallable): > > self.__call__ = anycallable > > > >class Foo(SQLObject): > > name = StringCol(alternateID=True) > > serial = StringCol(unique=True, notNone=False, default=None) > > > > def bySerial(serial): > > for foo in Foo.select(): > > if foo.serial != None and foo.serial == serial: > > return foo > > raise SQLObjectNotFound, "The %s identified by serial=%s does not > > exist" % (Foo.__name__, repr(serial)) > > bySerial = Callable(bySerial) > > > > > >if __name__ == "__main__": > > sqlhub.processConnection = connectionForURI('sqlite:/:memory:') > > Foo.createTable() > > > > foo1 = Foo(name="bob") > > foo2 = Foo(name="joe", serial="42") > > > > print Foo.byName("bob") > > print Foo.bySerial("42") > >--- cut --- > > > > > > > >------------------------------------------------------- > >This SF.Net email is sponsored by: > >Power Architecture Resource Center: Free content, downloads, discussions, > >and more. http://solutions.newsforge.com/ibmarch.tmpl > >_______________________________________________ > >sqlobject-discuss mailing list > >sql...@li... > >https://lists.sourceforge.net/lists/listinfo/sqlobject-discuss > > |
From: Jason P. <ce...@ic...> - 2005-10-19 19:49:50
|
On Wed, Oct 19, 2005 at 12:14:11PM -0500, Jason Pepas wrote: > The question I am facing now is this: If you can have unique=True *and* > notNone=False in the same column, what good reason is there for > alternateID to assert that notNone=True? > > Perhaps I should dive in and work up a patch which will allow the user > to override the default behavior of alternateID like so: > > StringCol(alternateID=True, notNone=False) I have whipped up two patches against col.py in 0.7 The first preserves the original functionality of sqlobject, but moves some of the logic around. In _extraSQL: def _extraSQL(self): result = [] if self.notNone or self.alternateID: result.append('NOT NULL') if self.unique or self.alternateID: result.append('UNIQUE') return result we see that some of the option interdependecy logic has bleed over into the surrounding code. Rather than checking self.alternateID in this function, ideally we should use self.alternateID to modify self.notNone and self.unique earlier in the code, so that we can have this instead: def _extraSQL(self): result = [] if self.notNone: result.append('NOT NULL') if self.unique: result.append('UNIQUE') return result The first patch implements the changes in code neccessary to do just that. This is mostly just reordinging things and a few minor changes. The second patch allows the user to explicitly override the behavior of alternateID implying notNone. Thus, the following becomes possible: StringCol(alternateID=True, notNone=False, default=None) I have also attached a test case and the original workaround. -jason pepas |
From: Oleg B. <ph...@ph...> - 2005-10-23 13:14:36
|
On Wed, Oct 19, 2005 at 02:49:42PM -0500, Jason Pepas wrote: > On Wed, Oct 19, 2005 at 12:14:11PM -0500, Jason Pepas wrote: > > The question I am facing now is this: If you can have unique=True *and* > > notNone=False in the same column, what good reason is there for > > alternateID to assert that notNone=True? > > > > Perhaps I should dive in and work up a patch which will allow the user > > to override the default behavior of alternateID like so: > > > > StringCol(alternateID=True, notNone=False) > > I have whipped up two patches against col.py in 0.7 > > The first preserves the original functionality of sqlobject, but moves > some of the logic around. > > In _extraSQL: > > def _extraSQL(self): > result = [] > if self.notNone or self.alternateID: > result.append('NOT NULL') > if self.unique or self.alternateID: > result.append('UNIQUE') > return result > > we see that some of the option interdependecy logic has bleed over into > the surrounding code. Rather than checking self.alternateID in this function, > ideally we should use self.alternateID to modify self.notNone and self.unique > earlier in the code, so that we can have this instead: > > def _extraSQL(self): > result = [] > if self.notNone: > result.append('NOT NULL') > if self.unique: > result.append('UNIQUE') > return result > > The first patch implements the changes in code neccessary to do just that. > This is mostly just reordinging things and a few minor changes. > > The second patch allows the user to explicitly override the behavior of > alternateID implying notNone. Thus, the following becomes possible: > > StringCol(alternateID=True, notNone=False, default=None) It seems to me you are trying to make "unique" and "alternateID" equivalent. My opinion is this: if we would do it we should do it other way round - to disable nonNone=False for both. Oleg. -- Oleg Broytmann http://phd.pp.ru/ ph...@ph... Programmers don't die, they just GOSUB without RETURN. |