425 lines
12 KiB
Python
425 lines
12 KiB
Python
# Relation
|
|
# Copyright (C) 2008 Salvo "LtWorf" Tomaselli
|
|
#
|
|
# Relation is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# author Salvo "LtWorf" Tomaselli <tiposchi@tiscali.it>
|
|
|
|
class relation (object):
|
|
'''This objects defines a relation (as a group of consistent tuples) and operations
|
|
A relation can be represented using a table
|
|
Calling an operation and providing a non relation parameter when it is expected will
|
|
result in a None value'''
|
|
def __init__(self,filename=""):
|
|
'''Creates a relation, accepts a filename and then it will load the relation from
|
|
that file. If no parameter is supplied an empty relation is created. Empty
|
|
relations are used in internal operations'''
|
|
if len(filename)==0:#Empty relation
|
|
self.content=[]
|
|
self.header=header([])
|
|
return
|
|
fp=file(filename)
|
|
self.header=header(fp.readline().replace("\n","").strip().split(" "))
|
|
|
|
self.content=[]
|
|
row=fp.readline()
|
|
while len(row)!=0:#Reads the content of the relation
|
|
self.content.append(row.replace("\n","").strip().split(" "))
|
|
row=fp.readline()
|
|
fp.close()
|
|
|
|
|
|
def save(self,filename):
|
|
'''Saves the relation in a file'''
|
|
res=""
|
|
for f in self.header.attributes:
|
|
res+="%s "%(f)
|
|
|
|
|
|
for r in self.content:
|
|
res+="\n"
|
|
for i in r:
|
|
res+="%s "% (i)
|
|
fp=file(filename,'w')
|
|
fp.write(res)
|
|
fp.close()
|
|
def rearrange(self,other):
|
|
'''If two relations share the same attributes in a different order, this method
|
|
will use projection to make them have the same attributes' order.
|
|
It is not exactely related to relational algebra. Just a method used
|
|
internally.
|
|
Will return None if they don't share the same attributes'''
|
|
if (self.__class__!=other.__class__):
|
|
return None
|
|
if self.header.sharedAttributes(other.header) == len(self.header.attributes) == len(other.header.attributes):
|
|
return other.projection(list(self.header.attributes))
|
|
return None
|
|
|
|
def selection(self,expr):
|
|
'''Selection, expr must be a valid boolean expression, can contain field names,
|
|
constant, math operations and boolean ones.'''
|
|
attributes={}
|
|
newt=relation()
|
|
newt.header=header(list(self.header.attributes))
|
|
for i in self.content:
|
|
for j in range(len(self.header.attributes)):
|
|
if i[j].isdigit():
|
|
attributes[self.header.attributes[j]]=int(i[j])
|
|
else:
|
|
attributes[self.header.attributes[j]]=i[j]
|
|
|
|
|
|
|
|
if eval(expr,attributes):
|
|
newt.content.append(i)
|
|
return newt
|
|
def product (self,other):
|
|
'''Cartesian product, attributes must be different to avoid collisions
|
|
Doing this operation on relations with colliding attributes will
|
|
cause the return of a None value.
|
|
It is possible to use rename on attributes and then use the product'''
|
|
|
|
if (self.__class__!=other.__class__)or(self.header.sharedAttributes(other.header)!=0):
|
|
return None
|
|
newt=relation()
|
|
newt.header=header(self.header.attributes+other.header.attributes)
|
|
|
|
for i in self.content:
|
|
for j in other.content:
|
|
newt.content.append(i+j)
|
|
return newt
|
|
|
|
|
|
def projection(self,* attributes):
|
|
'''Projection operator, takes many parameters, for each field to use.
|
|
Can also use a single parameter with a list.
|
|
Will delete duplicate items
|
|
If an empty list or no parameters are provided, returns None'''
|
|
#Parameters are supplied in a list, instead with multiple parameters
|
|
if attributes[0].__class__ == list().__class__:
|
|
attributes=attributes[0]
|
|
|
|
#Avoiding duplicated attributes
|
|
attributes1=[]
|
|
for i in attributes:
|
|
if i not in attributes1:
|
|
attributes1.append(i)
|
|
attributes=attributes1
|
|
|
|
ids=self.header.getAttributesId(attributes)
|
|
|
|
if len(ids)==0:
|
|
return None
|
|
newt=relation()
|
|
#Create the header
|
|
h=[]
|
|
for i in ids:
|
|
h.append(self.header.attributes[i])
|
|
newt.header=header(h)
|
|
|
|
#Create the body
|
|
for i in self.content:
|
|
row=[]
|
|
for j in ids:
|
|
row.append(i[j])
|
|
if row not in newt.content:#Avoids duplicated items
|
|
newt.content.append(row)
|
|
return newt
|
|
|
|
|
|
|
|
def rename(self,*params):
|
|
'''Operation rename. Takes an even number of parameters: (old,new,old,new....)
|
|
Will replace the 1st parameter with the 2nd, the 3rd with 4th, and so on...
|
|
If an "old" field doesn't exist, None will be returned'''
|
|
result=[]
|
|
|
|
newt=relation()
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
for i in range(len(params)):
|
|
if i%2==0:
|
|
if (newt.header.rename(params[i],params[i+1])) == False:
|
|
return None
|
|
|
|
newt.content=list(self.content)
|
|
return newt
|
|
|
|
def intersection(self,other):
|
|
'''Intersection operation. The result will contain items present in both
|
|
operands.
|
|
Will return an empty one if there are no common items.
|
|
Will return None if headers are different.
|
|
It is possible to use projection and rename to make headers match.'''
|
|
other=self.rearrange(other) #Rearranges attributes' order
|
|
if (self.__class__!=other.__class__)or(self.header!=other.header):
|
|
return None
|
|
newt=relation()
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
#Adds only element not in other, duplicating them
|
|
for e in self.content:
|
|
if e in other.content:
|
|
newt.content.append(list(e))
|
|
return newt
|
|
|
|
def difference(self,other):
|
|
'''Difference operation. The result will contain items present in first
|
|
operand but not in second one.
|
|
Will return an empty one if the second is a superset of first.
|
|
Will return None if headers are different.
|
|
It is possible to use projection and rename to make headers match.'''
|
|
other=self.rearrange(other) #Rearranges attributes' order
|
|
if (self.__class__!=other.__class__)or(self.header!=other.header):
|
|
return None
|
|
newt=relation()
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
#Adds only element not in other, duplicating them
|
|
for e in self.content:
|
|
if e not in other.content:
|
|
newt.content.append(list(e))
|
|
return newt
|
|
|
|
def union(self,other):
|
|
'''Union operation. The result will contain items present in first
|
|
and second operands.
|
|
Will return an empty one if both are empty.
|
|
Will not insert tuplicated items.
|
|
Will return None if headers are different.
|
|
It is possible to use projection and rename to make headers match.'''
|
|
other=self.rearrange(other) #Rearranges attributes' order
|
|
if (self.__class__!=other.__class__)or(self.header!=other.header):
|
|
return None
|
|
newt=relation()
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
#Adds element from self, duplicating them all
|
|
for e in self.content:
|
|
newt.content.append(list(e))
|
|
|
|
for e in other.content:
|
|
if e not in newt.content:
|
|
newt.content.append(list(e))
|
|
return newt
|
|
def thetajoin(self,other,expr):
|
|
'''Defined as product and then selection with the given expression.'''
|
|
return self.product(other).selection(expr)
|
|
|
|
def outer(self,other):
|
|
'''Does a left and a right outer join and returns their union.'''
|
|
a=self.outer_right(other)
|
|
b=self.outer_left(other)
|
|
print a
|
|
print b
|
|
|
|
return a.union(b)
|
|
|
|
def outer_right(self,other):
|
|
'''Same as left join, with swapped parameters'''
|
|
return self.outer_left(other,True)
|
|
|
|
def outer_left(self,other,swap=False):
|
|
'''Outer left join. Considers self as left and param as right. If the
|
|
tuple has no corrispondence, empty attributes are filled with a "---"
|
|
string. This is due to the fact that empty string or a space would cause
|
|
problems when saving the relation.
|
|
Just like natural join, it works considering shared attributes.
|
|
If swap is True, it will behave as a right join'''
|
|
|
|
if swap:
|
|
tmp=other
|
|
other=self
|
|
self=tmp
|
|
|
|
shared=[]
|
|
for i in self.header.attributes:
|
|
if i in other.header.attributes:
|
|
shared.append(i)
|
|
|
|
newt=relation() #Creates the new relation
|
|
|
|
#Adds all the attributes of the 1st relation
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
#Adds all the attributes of the 2nd, when non shared
|
|
for i in other.header.attributes:
|
|
if i not in shared:
|
|
newt.header.attributes.append(i)
|
|
#Shared ids of self
|
|
sid=self.header.getAttributesId(shared)
|
|
#Shared ids of the other relation
|
|
oid=other.header.getAttributesId(shared)
|
|
|
|
#Non shared ids of the other relation
|
|
noid=[]
|
|
for i in range(len(other.header.attributes)):
|
|
if i not in oid:
|
|
noid.append(i)
|
|
|
|
for i in self.content:
|
|
#Tuple partecipated to the join?
|
|
added=False
|
|
for j in other.content:
|
|
match=True
|
|
for k in range(len(sid)):
|
|
match=match and ( i[sid[k]]== j[oid[k]])
|
|
|
|
if match:
|
|
item=list(i)
|
|
for l in noid:
|
|
item.append(j[l])
|
|
|
|
newt.content.append(item)
|
|
added=True
|
|
#If it didn't partecipate, adds it
|
|
if not added:
|
|
item=list(i)
|
|
for l in range(len(noid)):
|
|
item.append("---")
|
|
newt.content.append(item)
|
|
|
|
return newt
|
|
|
|
def join(self,other):
|
|
'''Natural join, joins on shared attributes (one or more). If there are no
|
|
shared attributes, it will behave as cartesian product.'''
|
|
shared=[]
|
|
for i in self.header.attributes:
|
|
if i in other.header.attributes:
|
|
shared.append(i)
|
|
|
|
newt=relation() #Creates the new relation
|
|
|
|
#Adds all the attributes of the 1st relation
|
|
newt.header=header(list(self.header.attributes))
|
|
|
|
#Adds all the attributes of the 2nd, when non shared
|
|
for i in other.header.attributes:
|
|
if i not in shared:
|
|
newt.header.attributes.append(i)
|
|
#Shared ids of self
|
|
sid=self.header.getAttributesId(shared)
|
|
#Shared ids of the other relation
|
|
oid=other.header.getAttributesId(shared)
|
|
|
|
#Non shared ids of the other relation
|
|
noid=[]
|
|
for i in range(len(other.header.attributes)):
|
|
if i not in oid:
|
|
noid.append(i)
|
|
|
|
for i in self.content:
|
|
for j in other.content:
|
|
match=True
|
|
for k in range(len(sid)):
|
|
match=match and ( i[sid[k]]== j[oid[k]])
|
|
|
|
if match:
|
|
item=list(i)
|
|
for l in noid:
|
|
item.append(j[l])
|
|
|
|
newt.content.append(item)
|
|
|
|
return newt
|
|
|
|
def __str__(self):
|
|
'''Returns a string representation of the relation, can be printed with
|
|
monospaced fonts'''
|
|
m_len=[] #Maximum lenght string
|
|
for f in self.header.attributes:
|
|
m_len.append(len(f))
|
|
|
|
for f in self.content:
|
|
col=0
|
|
for i in f:
|
|
if len(i)>m_len[col]:
|
|
m_len[col]=len(i)
|
|
col+=1
|
|
|
|
|
|
res=""
|
|
for f in range(len(self.header.attributes)):
|
|
res+="%s"%(self.header.attributes[f].ljust(2+m_len[f]))
|
|
|
|
|
|
for r in self.content:
|
|
col=0
|
|
res+="\n"
|
|
for i in r:
|
|
res+="%s"% (i.ljust(2+m_len[col]))
|
|
col+=1
|
|
|
|
return res
|
|
|
|
class header (object):
|
|
'''This class defines the header of a relation.
|
|
It is used within relations to know if requested operations are accepted'''
|
|
|
|
def __init__(self,attributes):
|
|
'''Accepts a list with attributes' names. Names MUST be unique'''
|
|
self.attributes=attributes
|
|
def __repr__(self):
|
|
return "header(%s)" % (self.attributes.__repr__())
|
|
|
|
|
|
def rename(self,old,new):
|
|
'''Renames a field. Doesn't check if it is a duplicate.
|
|
Returns True if the field was renamed, False otherwise'''
|
|
for i in range(len(self.attributes)):
|
|
if self.attributes[i]==old:
|
|
self.attributes[i]=new
|
|
return True
|
|
return False #Requested field was not found
|
|
|
|
|
|
def sharedAttributes(self,other):
|
|
'''Returns how many attributes this header has in common with a given one'''
|
|
res=0
|
|
for i in self.attributes:
|
|
if i in other.attributes:
|
|
res+=1
|
|
return res
|
|
|
|
def __str__(self):
|
|
'''Returns String representation of the field's list'''
|
|
return self.attributes.__str__()
|
|
|
|
def __eq__(self,other):
|
|
return self.attributes==other.attributes
|
|
def __ne__(self,other):
|
|
return self.attributes!=other.attributes
|
|
|
|
def getAttributesId(self,param):
|
|
'''Returns a list with numeric index corresponding to field's name'''
|
|
res=[]
|
|
for i in param:
|
|
for j in range(len(self.attributes)):
|
|
if i==self.attributes[j]:
|
|
res.append(j)
|
|
return res
|
|
|
|
if __name__=="__main__":
|
|
a=["id","nome","cognome"]
|
|
|
|
b=header(a)
|
|
print "b=", b.__repr__()
|
|
b.rename("nome","nick")
|
|
|
|
a=["id","nome","cognome"]
|
|
c=header(a)
|
|
print b, c
|
|
print b==c
|
|
|