def _test_consistency(self):
"""All ids are unique. All referenced foreign keys exist."""
tmp = cache_is_on()
cache_off()
print 'Testing %s' % self.__class__,__name__
ok = 1
res = self.querySQL.executeQuery(where='')
iddict = {}
for tuple in res:
dict = sql.tuple2dict(tuple, self.querySQL.fieldnames)
m = self.__class__()
m.data = dict
id = self.primarykey
if id:
if iddict.has_key(m.data[id]):
print " Key %s occurs multiple times in %s" \
% (m.data[id], self.__class__.__name__)
ok = 0
iddict[m.data[id]] = 1
ok = m._test_foreign_keys()
#print len(res), len(iddict)
#print res, iddict
if ok:
print 'Class %s is consistent (%s different keys)' \
% (self.__class__.__name__, len(res))
else:
print '***** %s is inconsistent (%s different keys)' \
% (self.__class__.__name__, len(res))
if tmp: cache_on()
return ok
def __init__(self, s_NXXlnokey_word = None, **params):
# s_NXXlnokey_word wird wohl niemand als Parameter für den Aufruf nehmen,
# d.h. es ist nur belegt, wenn __init__ ohne keywords aufgerufen wurde.
# Wir nehmen dann an, daß es sich um den Wert für den primarykey handelt.
# self.changed = 0
if not s_NXXlnokey_word is None:
if _cache.get(self, s_NXXlnokey_word):
## if self._test_data():
## print self._test_data()
## print self.data
## raise AttributeError, 'in __getitem__'
return
primarykeyval = s_NXXlnokey_word
if params:
raise DBAppError("No additional parameters allowed if primarykey value is given.")
params[self.primarykey] = primarykeyval
elif not params:
# keine Parameter, leeres, unregistriertes Objekt
self.data = {}
return
self.data = params
if _cache.get(self):
return
wherelist = []
for k,v in params.items():
wherelist.append("%s = %s" % (k, sql.msql_quote(v)))
where = string.join(wherelist, ' and ')
res = self.querySQL.executeQuery(where)
if len(res) != 1:
raise DBAppError(
"No unique object for given parameters: %s (class %s)"
% (params, self.__class__.__name__))
self.data = sql.tuple2dict(res[0], self.querySQL.fieldnames)
self.data['__p__'] = 1
_cache.cache(self)
def __init__(self, data = [], where = None, k2 = None, v2 = None, order = '', join = []):
self.data = []
if data and where is None:
if type(data) == type([]):
# Initialisierung mit Liste von ids
if type(data[0]) in (type(1L), type(1)):
for id in data:
self.data.append(self.resultClass(id))
# Initialisierung mit Liste von Objekten
elif isinstance(data[0], self.resultClass):
self.data = data
else:
raise DBAppError('Wrong data for initialization of Container: %s', data)
elif isinstance(data, self.__class__):
# Initialisierung mit Container
self.data = data.data
else:
raise DBAppError('Wrong data for initialization of Container: %s', data)
return
if data and not where is None: # wird als feld = wert interpretiert
where = "%s = %s" % (data, sql.msql_quote(where))
if k2 and not v2 is None:
where = "%s and %s = %s" % (where, k2, sql.msql_quote(v2))
if not where is None:
where, order, join = self._expand(where, order, join)
res = self.querySQL.executeQuery(where, order, join)
for tuple in res:
dict = sql.tuple2dict(tuple, self.querySQL.fieldnames)
m = self.resultClass()
m.data = dict
# m.data may be replaced by an already cached state of the object
# the values from the database should be identical to the cached
# values, but the cached object may have additional values
if _cache.get(m):
# vielleicht besser:
# assert m.data == dict (nicht ganz, da es auch noch gecachte paths geben kann)
m.data.update(dict)
else:
m.data['__p__'] = 1
_cache.cache(m)
self.data.append(m)
def byQuery(self, query, **params):
"""Es müssen alle Feldnamen einer Tabelle in der richtigen Reihenfolge
der Tabellenfelder in der Select-Anweisung aufgeführt sein (!), wenn
die Klasse SQL in sql.py direkt für Select-Statements benutzt wird
sein. """
res = query.execute(params)
self.data = []
fields = self.resultClass.fields
for tuple in res:
dict = sql.tuple2dict(tuple, fields)
m = self.resultClass()
m.data = dict
if _cache.get(m):
m.data.update(dict)
else:
m.data['__p__'] = 1
_cache.cache(m)
self.data.append(m)
return self
def __init__(self, s_NXXlnokey_word = None, **params):
# s_NXXlnokey_word wird wohl niemand als Parameter für den Aufruf nehmen,
# d.h. es ist nur belegt, wenn __init__ ohne keywords aufgerufen wurde.
# Wir nehmen dann an, daß es sich um den Wert für den primarykey handelt.
# self.changed = 0
if not s_NXXlnokey_word is None:
# Hier gibt es nur Treffer, wenn s_NXXlnokey_word im Normalfall
# ein Integer ist. Falls die ID als String übergeben wird,
# kommt weiter unten die SQL-Query zum Zuge. Ebenfalls erfolgreich,
# aber unter Umgehung des Caches
# Braucht man den Cache überhaupt?
if _cache.get(self, s_NXXlnokey_word):
return
primarykeyval = s_NXXlnokey_word
if params:
raise DBAppError("No additional parameters allowed if primarykey value is given.")
params[self.primarykey] = primarykeyval
elif not params:
# keine Parameter, leeres, unregistriertes Objekt
self.data = {}
return
self.data = params
if _cache.get(self):
return
wherelist = []
for k,v in params.items():
wherelist.append("%s = %s" % (k, sql.msql_quote(v)))
where = string.join(wherelist, ' and ')
res = self.querySQL.executeQuery(where)
if len(res) != 1:
raise DBAppError(
"No unique object for given parameters: %s (class %s)"
% (params, self.__class__.__name__))
self.data = sql.tuple2dict(res[0], self.querySQL.fieldnames)
self.data['__p__'] = 1
_cache.cache(self)