Lines Matching full:self
24 # def _defineRows(self):
25 # self.d_addColumn("agent_id",kInteger,None,primarykey = 1,autoincrement = 1)
26 # self.d_addColumn("login",kVarString,200,notnull=1)
27 # self.d_addColumn("ticket_count",kIncInteger,None)
93 def __init__(self, db, debug=0):
94 self._tables = {}
95 self.db = db
96 self._cursor = None
97 self.compression_enabled = 0
98 self.debug = debug
99 self.SQLError = None
101 self.__defaultRowClass = self.defaultRowClass()
102 self.__defaultRowListClass = self.defaultRowListClass()
104 def defaultCursor(self):
105 if self._cursor is None:
106 self._cursor = self.db.cursor()
107 return self._cursor
109 def escape(self,str):
112 def getDefaultRowClass(self): return self.__defaultRowClass
113 def setDefaultRowClass(self, clss): self.__defaultRowClass = clss
114 def getDefaultRowListClass(self): return self.__defaultRowListClass
115 def setDefaultRowListClass(self, clss): self.__defaultRowListClass = clss
117 def defaultRowClass(self):
120 def defaultRowListClass(self):
124 def addTable(self, attrname, tblname, tblclass,
126 tbl = tblclass(self, tblname, rowClass=rowClass, check=check,
128 self._tables[attrname] = tbl
131 def close(self):
132 for name, tbl in self._tables.items():
134 self._tables = {}
135 if self.db is not None:
136 self.db.close()
137 self.db = None
139 def __getattr__(self, key):
141 raise AttributeError, "odb.Database: not initialized properly, self._tables does not exist"
144 table_dict = getattr(self,"_tables")
149 def beginTransaction(self, cursor=None):
151 cursor = self.defaultCursor()
155 def commitTransaction(self, cursor=None):
157 cursor = self.defaultCursor()
161 def rollbackTransaction(self, cursor=None):
163 cursor = self.defaultCursor()
171 def createTables(self):
172 tables = self.listTables()
174 for attrname, tbl in self._tables.items():
183 ## self.alterTableToMatch(tbl)
185 def createIndices(self):
186 indices = self.listIndices()
188 for attrname, tbl in self._tables.items():
194 def synchronizeSchema(self):
195 tables = self.listTables()
197 for attrname, tbl in self._tables.items():
199 self.alterTableToMatch(tbl)
201 def listTables(self, cursor=None):
204 def listFieldsDict(self, table_name, cursor=None):
207 def listFields(self, table_name, cursor=None):
208 columns = self.listFieldsDict(table_name, cursor=cursor)
217 def subclassinit(self):
219 def __init__(self,database,table_name,
221 self.db = database
222 self.__table_name = table_name
224 self.__defaultRowClass = rowClass
226 self.__defaultRowClass = database.getDefaultRowClass()
229 self.__defaultRowListClass = rowListClass
231 self.__defaultRowListClass = database.getDefaultRowListClass()
235 self.__column_list = []
236 self.__vcolumn_list = []
237 self.__columns_locked = 0
238 self.__has_value_column = 0
240 self.__indices = {}
243 self.__col_def_hash = None
244 self.__vcol_def_hash = None
245 self.__primary_key_list = None
246 self.__relations_by_table = {}
249 self._defineRows()
252 self.__lockColumnsAndInit()
254 self.subclassinit()
257 self.createTable()
260 self.checkTable()
262 def _colTypeToSQLType(self, colname, coltype, options):
295 def getTableName(self): return self.__table_name
296 def setTableName(self, tablename): self.__table_name = tablename
298 def getIndices(self): return self.__indices
300 def _createTableSQL(self):
302 for colname, coltype, options in self.__column_list:
303 defs.append(self._colTypeToSQLType(colname, coltype, options))
307 primarykeys = self.getPrimaryKeyList()
312 sql = "create table %s (%s %s)" % (self.__table_name, defs, primarykey_str)
315 def createTable(self, cursor=None):
316 if cursor is None: cursor = self.db.defaultCursor()
317 sql = self._createTableSQL()
321 def dropTable(self, cursor=None):
322 if cursor is None: cursor = self.db.defaultCursor()
324 cursor.execute("drop table %s" % self.__table_name) # clean out the table
325 except self.SQLError, reason:
328 def renameTable(self, newTableName, cursor=None):
329 if cursor is None: cursor = self.db.defaultCursor()
331 cursor.execute("rename table %s to %s" % (self.__table_name, newTableName))
335 self.setTableName(newTableName)
337 def getTableColumnsFromDB(self):
338 return self.db.listFieldsDict(self.__table_name)
340 def checkTable(self, warnflag=1):
344 dbcolumns = self.getTableColumnsFromDB()
345 for coldef in self.__column_list:
353 coldef = self.__col_def_hash.get(colname, None)
375 def alterTableToMatch(self):
378 def addIndex(self, columns, indexName=None, unique=0):
380 indexName = self.getTableName() + "_index_" + string.join(columns, "_")
382 self.__indices[indexName] = (columns, unique)
384 def createIndex(self, columns, indexName=None, unique=0, cursor=None):
385 if cursor is None: cursor = self.db.defaultCursor()
389 indexName = self.getTableName() + "_index_" + string.join(columns, "_")
394 sql = "create %s index %s on %s (%s)" % (uniquesql, indexName, self.getTableName(), cols)
401 def getColumnDef(self,column_name):
403 return self.__col_def_hash[column_name]
406 return self.__vcol_def_hash[column_name]
408 raise eNoSuchColumn, "no column (%s) on table %s" % (column_name,self.__table_name)
410 def getColumnList(self):
411 return self.__column_list + self.__vcolumn_list
412 def getAppColumnList(self): return self.__column_list
414 def databaseSizeForData_ColumnName_(self,data,col_name):
416 col_def = self.__col_def_hash[col_name]
419 col_def = self.__vcol_def_hash[col_name]
421 raise eNoSuchColumn, "no column (%s) on table %s" % (col_name,self.__table_name)
426 if c_options.get("compress_ok",0) and self.db.compression_enabled:
444 def columnType(self, col_name):
446 col_def = self.__col_def_hash[col_name]
449 col_def = self.__vcol_def_hash[col_name]
451 raise eNoSuchColumn, "no column (%s) on table %s" % (col_name,self.__table_name)
456 def convertDataForColumn(self,data,col_name):
458 col_def = self.__col_def_hash[col_name]
461 col_def = self.__vcol_def_hash[col_name]
463 raise eNoSuchColumn, "no column (%s) on table %s" % (col_name,self.__table_name)
468 raise eInvalidData, "invalid operation for column (%s:%s) on table (%s)" % (col_name,c_type,self.__table_name)
475 raise eInvalidData, "invalid data (%s) for col (%s:%s) on table (%s)" % (repr(data),col_name,c_type,self.__table_name)
481 raise eInvalidData, "invalid data (%s) for col (%s:%s) on table (%s)" % (repr(data), col_name,c_type,self.__table_name)
489 def getPrimaryKeyList(self):
490 return self.__primary_key_list
492 def hasValueColumn(self):
493 return self.__has_value_column
495 def hasColumn(self,name):
496 return self.__col_def_hash.has_key(name)
497 def hasVColumn(self,name):
498 return self.__vcol_def_hash.has_key(name)
501 def _defineRows(self):
504 def __lockColumnsAndInit(self):
506 if self.__has_value_column:
507 self.d_addColumn("odb_value",kBigText,default='')
509 self.__columns_locked = 1
514 for a_col in self.__column_list:
520 self.__col_def_hash = col_def_hash
521 self.__primary_key_list = primary_key_list
525 if (not self.__has_value_column) and (len(self.__vcolumn_list) > 0):
529 for a_col in self.__vcolumn_list:
533 self.__vcol_def_hash = vcol_def_hash
536 def __checkColumnLock(self):
537 if self.__columns_locked:
547 # def _defineRows(self):
548 # self.d_addColumn("id",kInteger,primarykey = 1,autoincrement = 1)
549 # self.d_addColumn("name",kVarString,120)
550 # self.d_addColumn("type",kInteger,
553 def d_addColumn(self,col_name,ctype,size=None,primarykey = 0,
560 self.__checkColumnLock()
570 self.addIndex((col_name,))
592 raise eInvalidData, "enum_values paramater must be a 1 to 1 mapping for Table(%s)" % self.__table_name
600 if self.__relations_by_table.has_key(table):
602 self.__relations_by_table[table] = (col_name,foreign_column_name)
609 self.__column_list.append( (col_name,ctype,options) )
611 def d_addValueColumn(self):
612 self.__checkColumnLock()
613 self.__has_value_column = 1
615 def d_addVColumn(self,col_name,type,size=None,default=None):
616 self.__checkColumnLock()
618 if (not self.__has_value_column):
627 self.__vcolumn_list.append( (col_name,type,options) )
639 def _fixColMatchSpec(self,col_match_spec, should_match_unique_row = 0):
658 for a_key in self.__primary_key_list:
662 for a_col in self.__column_list:
676 if not self.__col_def_hash.has_key(newname):
700 def __buildWhereClause (self, col_match_spec,other_clauses = None):
706 c_name,c_type,c_options = self.__col_def_hash[m_col_name]
711 raise ValueError, "invalid literal for long(%s) in table %s" % (repr(m_col_val),self.__table_name)
718 raise ValueError, "invalid literal for float(%s) is table %s" % (repr(m_col_val), self.__table_name)
721 sql_where_list.append("%s = '%s'" % (c_name, self.db.escape(m_col_val)))
734 def __fetchRows(self,col_match_spec,cursor = None, where = None, order_by = None, limit_to = None,
737 cursor = self.db.defaultCursor()
741 for name,t,options in self.__column_list:
752 my_col,foreign_col = self.__relations_by_table[a_table]
762 eInvalidJoinSpec, "can't find table %s in defined relations for %s" % (a_table,self.__table_name)
766 self.__table_name)
773 sql_where_list = self.__buildWhereClause (col_match_spec,where)
785 if self.db.db.__module__ == "sqlite.main":
799 return_rows = self.__defaultRowListClass()
811 if self.__col_def_hash.has_key(name) or joined_cols_hash.has_key(name):
813 if self.__col_def_hash.has_key(name):
814 c_name,c_type,c_options = self.__col_def_hash[name]
836 newrowobj = self.__defaultRowClass(self,data_dict,joined_cols = joined_cols)
843 def __deleteRow(self,a_row,cursor = None):
845 cursor = self.db.defaultCursor()
849 sql_where_list = self.__buildWhereClause (match_spec)
851 sql = "delete from %s where %s" % (self.__table_name,
857 def __updateRowList(self,a_row_list,cursor = None):
859 cursor = self.db.defaultCursor()
868 c_name,c_type,c_options = self.__col_def_hash[col_name]
879 elif c_type == kBigString and c_options.get("compress_ok",0) and self.db.compression_enabled:
882 sql_set_list.append("%s = '%s'" % (c_name, self.db.escape(compressed_data)))
884 sql_set_list.append("%s = '%s'" % (c_name, self.db.escape(col_val)))
889 sql_set_list.append("%s = '%s'" % (c_name, self.db.escape(col_val)))
893 sql_where_list = self.__buildWhereClause (match_spec)
896 sql = "update %s set %s where %s" % (self.__table_name,
909 def __insertRow(self,a_row_obj,cursor = None,replace=0):
911 cursor = self.db.defaultCursor()
917 for a_col in self.__column_list:
929 elif type == kBigString and options.get("compress_ok",0) and self.db.compression_enabled:
932 sql_data_list.append("'%s'" % self.db.escape(compressed_data))
934 sql_data_list.append("'%s'" % self.db.escape(data))
938 sql_data_list.append("'%s'" % self.db.escape(data))
943 raise eInternalError, "two autoincrement columns (%s,%s) in table (%s)" % (auto_increment_column_name, name,self.__table_name)
948 sql = "replace into %s (%s) values (%s)" % (self.__table_name,
952 sql = "insert into %s (%s) values (%s)" % (self.__table_name,
988 def r_deleteRow(self,a_row_obj, cursor = None):
990 self.__deleteRow(a_row_obj, cursor = curs)
1000 def r_updateRow(self,a_row_obj, cursor = None):
1002 self.__updateRowList([a_row_obj], cursor = curs)
1011 def r_insertRow(self,a_row_obj, cursor = None,replace=0):
1013 self.__insertRow(a_row_obj, cursor = curs,replace=replace)
1032 def deleteRow(self,col_match_spec, where=None):
1033 n_match_spec = self._fixColMatchSpec(col_match_spec)
1034 cursor = self.db.defaultCursor()
1037 sql_where_list = self.__buildWhereClause (n_match_spec,where)
1041 sql = "delete from %s where %s" % (self.__table_name, string.join(sql_where_list," and "))
1056 def fetchRow(self, col_match_spec, cursor = None):
1057 n_match_spec = self._fixColMatchSpec(col_match_spec, should_match_unique_row = 1)
1059 rows = self.__fetchRows(n_match_spec, cursor = cursor)
1077 def fetchRows(self, col_match_spec = None, cursor = None,
1080 n_match_spec = self._fixColMatchSpec(col_match_spec)
1082 return self.__fetchRows(n_match_spec,
1090 def fetchRowCount (self, col_match_spec = None,
1092 n_match_spec = self._fixColMatchSpec(col_match_spec)
1093 sql_where_list = self.__buildWhereClause (n_match_spec,where)
1094 sql = "select count(*) from %s" % self.__table_name
1098 cursor = self.db.defaultCursor()
1115 def fetchAllRows(self):
1117 return self.__fetchRows([])
1120 return self.__defaultRowListClass()
1122 def newRow(self,replace=0):
1123 row = self.__defaultRowClass(self,None,create=1,replace=replace)
1124 for (cname, ctype, opts) in self.__column_list:
1131 def subclassinit(self):
1133 def __init__(self,_table,data_dict,create=0,joined_cols = None,replace=0):
1135 self._inside_getattr = 0 # stop recursive __getattr__
1136 self._table = _table
1137 self._should_insert = create or replace
1138 self._should_replace = replace
1139 self._rowInactive = None
1140 self._joinedRows = []
1142 self.__pk_match_spec = None
1143 self.__vcoldata = {}
1144 self.__inc_coldata = {}
1146 self.__joined_cols_dict = {}
1148 self.__joined_cols_dict[a_col] = 1
1151 self.__coldata = {}
1155 self.__coldata = data_dict
1156 self.__unpackVColumn()
1158 self.markClean()
1160 self.subclassinit()
1161 self.__instance_data_locked = 1
1163 def joinRowData(self,another_row):
1164 self._joinedRows.append(another_row)
1166 def getPKMatchSpec(self):
1167 return self.__pk_match_spec
1169 def markClean(self):
1170 self.__vcolchanged = 0
1171 self.__colchanged_dict = {}
1173 for key in self.__inc_coldata.keys():
1174 self.__coldata[key] = self.__coldata.get(key, 0) + self.__inc_coldata[key]
1176 self.__inc_coldata = {}
1178 if not self._should_insert:
1181 for col_name in self._table.getPrimaryKeyList():
1183 rdata = self[col_name]
1185 raise eInternalError, "must have primary key data filled in to save %s:Row(col:%s)" % (self._table.getTableName(),col_name)
1188 self.__pk_match_spec = new_match_spec
1190 def __unpackVColumn(self):
1191 if self._table.hasValueColumn():
1194 def __packVColumn(self):
1195 if self._table.hasValueColumn():
1200 def __del__(self):
1202 changed_list = self.changedList()
1204 info = "unsaved Row for table (%s) lost, call discard() to avoid this error. Lost changes: %s\n" % (self._table.getTableName(), repr(changed_list)[:256])
1211 def __repr__(self):
1212 return "Row from (%s): %s" % (self._table.getTableName(),repr(self.__coldata) + repr(self.__vcoldata))
1216 def __getattr__(self,key):
1217 if self._inside_getattr:
1218 raise AttributeError, "recursively called __getattr__ (%s,%s)" % (key,self._table.getTableName())
1220 self._inside_getattr = 1
1222 return self[key]
1224 if self._table.hasColumn(key) or self._table.hasVColumn(key):
1227 raise AttributeError, "unknown field '%s' in Row(%s)" % (key,self._table.getTableName())
1229 self._inside_getattr = 0
1231 def __setattr__(self,key,val):
1232 if not self.__instance_data_locked:
1233 self.__dict__[key] = val
1235 my_dict = self.__dict__
1241 self[key] = val
1248 def __getitem__(self,key):
1249 self.checkRowActive()
1252 c_type = self._table.columnType(key)
1260 c_data = self.__coldata.get(key, 0)
1262 i_data = self.__inc_coldata.get(key, 0)
1267 return self.__coldata[key]
1270 return self.__vcoldata[key]
1272 for a_joined_row in self._joinedRows:
1278 raise KeyError, "unknown column %s in %s" % (key,self)
1280 def __setitem__(self,key,data):
1281 self.checkRowActive()
1284 newdata = self._table.convertDataForColumn(data,key)
1288 if self._table.hasColumn(key):
1289 self.__coldata[key] = newdata
1290 self.__colchanged_dict[key] = 1
1291 elif self._table.hasVColumn(key):
1292 self.__vcoldata[key] = newdata
1293 self.__vcolchanged = 1
1295 for a_joined_row in self._joinedRows:
1303 def __delitem__(self,key,data):
1304 self.checkRowActive()
1306 if self.table.hasVColumn(key):
1307 del self.__vcoldata[key]
1309 for a_joined_row in self._joinedRows:
1318 def copyFrom(self,source):
1319 for name,t,options in self._table.getColumnList():
1321 self[name] = source[name]
1326 def keys(self):
1327 self.checkRowActive()
1330 for name,t,options in self._table.getColumnList():
1332 for name in self.__joined_cols_dict.keys():
1335 for a_joined_row in self._joinedRows:
1341 def items(self):
1342 self.checkRowActive()
1345 for name,t,options in self._table.getColumnList():
1346 item_list.append( (name,self[name]) )
1347 for name in self.__joined_cols_dict.keys():
1348 item_list.append( (name,self[name]) )
1350 for a_joined_row in self._joinedRows:
1357 self.checkRowActive()
1359 value_list = self.__coldata.values() + self.__vcoldata.values()
1361 for a_joined_row in self._joinedRows:
1367 def __len__(self):
1368 self.checkRowActive()
1370 my_len = len(self.__coldata) + len(self.__vcoldata)
1372 for a_joined_row in self._joinedRows:
1377 def has_key(self,key):
1378 self.checkRowActive()
1380 if self.__coldata.has_key(key) or self.__vcoldata.has_key(key):
1384 for a_joined_row in self._joinedRows:
1389 def get(self,key,default = None):
1390 self.checkRowActive()
1394 if self.__coldata.has_key(key):
1395 return self.__coldata[key]
1396 elif self.__vcoldata.has_key(key):
1397 return self.__vcoldata[key]
1399 for a_joined_row in self._joinedRows:
1405 if self._table.hasColumn(key):
1410 def inc(self,key,count=1):
1411 self.checkRowActive()
1413 if self._table.hasColumn(key):
1415 self.__inc_coldata[key] = self.__inc_coldata[key] + count
1417 self.__inc_coldata[key] = count
1419 self.__colchanged_dict[key] = 1
1421 raise AttributeError, "unknown field '%s' in Row(%s)" % (key,self._table.getTableName())
1428 def fillDefaults(self):
1429 for field_def in self._table.fieldList():
1432 self[name] = options["default"]
1441 def changedList(self):
1442 if self.__vcolchanged:
1443 self.__packVColumn()
1446 for a_col in self.__colchanged_dict.keys():
1447 changed_list.append( (a_col,self.get(a_col,None),self.__inc_coldata.get(a_col,None)) )
1451 def discard(self):
1452 self.__coldata = None
1453 self.__vcoldata = None
1454 self.__colchanged_dict = {}
1455 self.__vcolchanged = 0
1457 def delete(self,cursor = None):
1458 self.checkRowActive()
1461 fromTable = self._table
1463 fromTable.r_deleteRow(self,cursor=curs)
1464 self._rowInactive = "deleted"
1466 def save(self,cursor = None):
1467 toTable = self._table
1469 self.checkRowActive()
1471 if self._should_insert:
1472 toTable.r_insertRow(self,replace=self._should_replace)
1473 self._should_insert = 0
1474 self._should_replace = 0
1475 self.markClean() # rebuild the primary key list
1478 toTable.r_updateRow(self,cursor = curs)
1481 # self.markClean()
1483 def checkRowActive(self):
1484 if self._rowInactive:
1485 raise eInvalidData, "row is inactive: %s" % self._rowInactive
1487 def databaseSizeForColumn(self,key):
1488 return self._table.databaseSizeForData_ColumnName_(self[key],key)
