def listNodesId(level=None, node_type=None): """List nodes from db. If level is passed returns from that level only, if node type is passed returns of that type only. If not all are returned. @param level from which the nodes are @param node_type @returns list the nodes """ list_nodes = [] if level is None: st = "SELECT id FROM gn____levels;" list_levels = db.query(st).getresult() for i in list_levels: tag_level = genet_global.tagName(i[0]) st = "SELECT id, idtype FROM gn_" + tag_level + "_nodes;" if node_type is not None: st = st[:-1] + " WHERE idtype = " + str(node_type) + ";" list_nodes += db.query(st).getresult() else: tag_level = genet_global.tagName(level) st = "SELECT id, idtype FROM gn_" + tag_level + "_nodes;" if node_type is not None: st = st[:-1] + " WHERE idtype = " + str(node_type) + ";" list_nodes = db.query(st).getresult() return list_nodes
def createEdgeType(level, description): """ Create one edge type. Construct the new tablename of type with the new type. @param level in which the new type is added. @param description of the type. """ st = ("INSERT INTO gn____edge_types(level, description) " "VALUES (" + level + ", '" + description + "') " "RETURNING ID;") id = db.query(st).getresult()[0][0] ret = st, id # Update tablename with the level and id. tag_level = genet_global.tagName(level) tag_id = genet_global.tagName(id) tablename = "gn_" + tag_level + "_edges_type_" + tag_id st = ("UPDATE gn____edge_types " "SET tablename = '" + tablename + "' " "WHERE id = " + str(id) + ";") ret = ret, st, db.query(st) # Create the table. ret = ret, db_schema.createEdgeTypeTable(tag_level, tablename) return ret
def connectNodes(level_id, idnA, idnB, parent_id, parentlevel_id, type_id, attributes): """Create edge in db. Uses Edge class for the edge creation and coding for the edge type attributes store. TODO store any attributes len. @param level id @param node A id @param node B id @param parent id @param parentlevel id @param type id @param attributes tuple of edge attributes """ E = class_edge.edge(level_id, idnA, idnB, parent_id, parentlevel_id, type_id) edge_id = E.store(db) tag_level = genet_global.tagName(level_id) tag_type = genet_global.tagName(type_id) st = ("INSERT INTO gn_" + tag_level + "_edges_type_" + tag_type + " VALUES(" + str(edge_id) + ", '" + attributes[0] + "');") db.query(st)
def dropLevel(level): """ @param level id to delete. """ # Drop the layer tables. tag_level = genet_global.tagName(level) ret = db_schema.dropLevelTables(tag_level) # Drop all type tables in the level. # Edges. st = ("SELECT id " "FROM gn____edge_types " "WHERE level = " + level + ";") ids = db.query(st).getresult() if len(ids): for i in ids: dropEdgeType(i[0]) # Nodes. st = ("SELECT id " "FROM gn____node_types " "WHERE level = " + level + ";") ids = db.query(st).getresult() if len(ids): for i in ids: dropNodeType(i[0]) # Delete entry into the levels table. st = ("DELETE FROM gn____levels " "WHERE id = " + level + ";") ret = ret, db.query(st) return ret
def store(self, db): """ Stores data in db. @param db is the database object. @returns the node id. TODO write log with db statements. """ # Uniformly define the tablename level. tag_level = genet_global.tagName(self.level) # If the node already exists. if self.id: # Update the nodes table. st1 = ( "UPDATE gn_" + tag_level + "_nodes SET " "idtype = " + str(self.idtype) + " " "WHERE id = " + str(self.id) + ";" ) db.query(st1) # Update the tree table. st2 = ( "UPDATE gn____tree SET " "idparent = " + str(self.idparent) + ", " "parentlevel = " + str(self.parentlevel) + ", " "childlevel = " + str(self.level) + " " "WHERE idchild = " + str(self.id) + ";" ) db.query(st2) return self.id # If the node does not exist. else: # Insert the node into the table. st1 = "INSERT INTO gn_" + tag_level + "_nodes(idtype) " "VALUES(" + str(self.idtype) + ") " "RETURNING id;" self.id = db.query(st1).getresult()[0][0] # Insert the node into the tree. st2 = ( "INSERT INTO gn____tree(idparent, idchild, " "parentlevel, childlevel) " "VALUES (" + str(self.idparent) + ", " + str(self.id) + ", " + str(self.parentlevel) + ", " + str(self.level) + ");" ) db.query(st2) return self.id
def listNodesAtt(level, node_type): """List node attributes from db. Returns data from all nodes from level and type passed. @param level from which the nodes are @param node_type @returns list the nodes """ list_nodes = [] tag_level = genet_global.tagName(level) tag_type = genet_global.tagName(node_type) st = ("SELECT * " "FROM gn_" + tag_level + "_nodes_type_" + tag_type + ";") list_nodes = db.query(st).getresult() return list_nodes
def createNode(level_id, parent_id, parentlevel_id, type_id, attributes): """Create node in db. Uses Node class for the node creation and coding for the node type attributes store. TODO store any attributes len. @param level id @param parent id @param parentlevel id @param type id @param attributes tuple of node attributes """ N = class_node.node(level_id, parent_id, parentlevel_id, type_id) node_id = N.store(db) tag_level = genet_global.tagName(level_id) tag_type = genet_global.tagName(type_id) st = ("INSERT INTO gn_" + tag_level + "_nodes_type_" + tag_type + " VALUES(" + str(node_id) + ", '" + attributes[0] + "');") db.query(st)
def createLevel(description): """ Create one level in the network data model. The level primary key is used to tag the table. @param description of the level. @returns queries statements and results. """ st = ("INSERT INTO gn____levels(description) " "VALUES ('" + description + "') " "RETURNING id;") level = db.query(st).getresult()[0][0] tag_level = genet_global.tagName(level) # Create the layer tables. ret = db_schema.createLevelTables(tag_level) return ret