[gentoo-commits] dev/zorry:master commit in: gobs/bin/, gobs/pym/

["Magnus Granberg" <zorry@gentoo.org>]

commit:     37d14f0a9ca1a7e0cccb485620322edd0e5e9967
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Sun Apr 24 22:12:29 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Sun Apr 24 22:12:29 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=37d14f0a

fix the delet old packages part

---
 gobs/bin/gobs_updatedb   |    4 +-
 gobs/pym/package.py      |   34 +-
 gobs/pym/pgsqlbackend.py |  760 ++++++++++++++++++++++++----------------------
 3 files changed, 411 insertions(+), 387 deletions(-)

diff --git a/gobs/bin/gobs_updatedb b/gobs/bin/gobs_updatedb
index a6afa17..582efa6 100755
--- a/gobs/bin/gobs_updatedb
+++ b/gobs/bin/gobs_updatedb
@@ -67,12 +67,12 @@ def update_cpv_db(mysettings, database, gobs_settings_dict):
 		# Check if we don't have the cp in the package table
 		package_id = database.have_package_db(categories, package)
 		if package_id is None:
-		# Add new package with ebuilds
+			# Add new package with ebuilds
 			package_id = init_package.add_new_package_db(categories, package)
 			package_id_list_tree.append(package_id)
 		# Ceck if we have the cp in the package table
 		elif package_id is not None:
-		# Update the packages with ebuilds
+			# Update the packages with ebuilds
 			init_package.update_package_db(categories, package, package_id)
 			package_id_list_tree.append(package_id)
 		# Update the metadata for categories

diff --git a/gobs/pym/package.py b/gobs/pym/package.py
index 1180bd2..ed8d70b 100644
--- a/gobs/pym/package.py
+++ b/gobs/pym/package.py
@@ -80,7 +80,7 @@ class gobs_package(object):
 		ebuild_version_text = self.init_text.get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
 		init_repoman = gobs_repoman(self.mysettings, self.myportdb, self.database)
 		repoman_error = init_repoman.check_repoman(categories, package, ebuild_version_tree, config_id)
-		ebuild_version_metadata_tree = get_ebuild_metadata(ebuild_line)
+		ebuild_version_metadata_tree = self.get_ebuild_metadata(ebuild_line)
 		# if there some error to get the metadata we add rubish to the 
 		# ebuild_version_metadata_tree and set ebuild_version_checksum_tree to 0
 		# so it can be updated next time we update the db
@@ -105,14 +105,14 @@ class gobs_package(object):
 		for k, v in packageDict.iteritems():
 			attDict = {}
 			metadata_restrictions = []
-		for i in v['ebuild_version_metadata_tree'][4].split():
-			metadata_restrictions.append(i)
+			for i in v['ebuild_version_metadata_tree'][4].split():
+				metadata_restrictions.append(i)
 			metadata_keyword = []
-		for i in v['ebuild_version_metadata_tree'][8].split():
-			metadata_keyword.append(i)
+			for i in v['ebuild_version_metadata_tree'][8].split():
+				metadata_keyword.append(i)
 			metadata_iuse = []
-		for i in v['ebuild_version_metadata_tree'][10].split():
-			metadata_iuse.append(i)
+			for i in v['ebuild_version_metadata_tree'][10].split():
+				metadata_iuse.append(i)
 			attDict['restrictions'] = metadata_restrictions
 			attDict['keyword'] = metadata_keyword
 			attDict['iuse'] =  metadata_iuse
@@ -174,7 +174,7 @@ class gobs_package(object):
 		pkgdir = self.mysettings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
 		categories_dir = self.mysettings['PORTDIR'] + "/" + categories + "/"
 		# Get the ebuild list for cp
-		ebuild_list_tree = self.portdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
+		ebuild_list_tree = self.myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
 		config_cpv_listDict = self.config_match_ebuild(categories, package)
 		config_id  = self.database.get_default_config()[0]
 		packageDict ={}
@@ -186,13 +186,9 @@ class gobs_package(object):
 			ebuild_id_list = return_id[0]
 			package_id_list = return_id[1]
 			package_id = package_id_list[0]
-			# Add the manifest file to db
-			manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-			get_manifest_text = self.init_text.get_file_text(pkgdir + "/Manifest")
-			database.add_new_manifest_sql(package_id, get_manifest_text, manifest_checksum_tree)
 			# Add metadataDict to db
 			metadataDict = self.get_metadataDict(packageDict, ebuild_id_list)
-			database.add_new_metadata(metadataDict)
+			self.database.add_new_metadata(metadataDict)
 			# Add any qa and repoman erro for the ebuild to buildlog
 			qa_error = []
 			init_manifest =  gobs_manifest(self.mysettings)
@@ -206,7 +202,11 @@ class gobs_package(object):
 			# Add some checksum on some files
 			package_metadataDict = self.get_package_metadataDict(pkgdir, package)
 			self.database.add_new_package_metadata(package_id, package_metadataDict)
-			return package_id
+			# Add the manifest file to db
+			manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
+			get_manifest_text = self.init_text.get_file_text(pkgdir + "/Manifest")
+			self.database.add_new_manifest_sql(package_id, get_manifest_text, manifest_checksum_tree)
+		return package_id
 
 	def update_package_db(self, categories, package, package_id):
 		# Update the categories and package with new info
@@ -214,7 +214,7 @@ class gobs_package(object):
 		# Get the checksum from the file in portage tree
 		manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
 		# Get the checksum from the db in package table
-		manifest_checksum_db = self.database.get_manifest_db(package_id)[0]
+		manifest_checksum_db = self.database.get_manifest_db(package_id)
 		# if we have the same checksum return else update the package
 		ebuild_list_tree = self.myportdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
 		if manifest_checksum_tree != manifest_checksum_db:
@@ -264,5 +264,5 @@ class gobs_package(object):
 			# Add the ebuild to the buildqueru table if needed
 			self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config_cpv_listDict)
 			# Mark or remove any old ebuilds
-			init_old_cpv = gobs_old_cpv(self.database, self.myportdb)
-			init_old_cpv.mark_old_ebuild_db(categories, package, package_id, sorted(ebuild_list_tree))
+			init_old_cpv = gobs_old_cpv(self.database, self.myportdb, self.mysettings)
+			init_old_cpv.mark_old_ebuild_db(categories, package, package_id)

diff --git a/gobs/pym/pgsqlbackend.py b/gobs/pym/pgsqlbackend.py
index 27fdf57..d89feec 100644
--- a/gobs/pym/pgsqlbackend.py
+++ b/gobs/pym/pgsqlbackend.py
@@ -1,377 +1,401 @@
    
 class SQLPackageDatabase(object):
-  """we have to store our stuff somewhere
-
-  subclass and redefine init to provide
-  at least self.cursor"""
-
-  # These are set by subclasses
-  db = None
-  cursor = None
-  syntax_placeholder = None
-  syntax_autoincrement = None
-
-  sql = {}
-
-  def get_default_config(self):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT id FROM configs WHERE default_config = True'
-    cursor.execute(sqlQ)
-    return cursor.fetchone()
+	"""we have to store our stuff somewhere
+	subclass and redefine init to provide
+	at least self.cursor"""
+
+	# These are set by subclasses
+	db = None
+	cursor = None
+	syntax_placeholder = None
+	syntax_autoincrement = None
+	sql = {}
+
+	def get_default_config(self):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT id FROM configs WHERE default_config = True'
+		cursor.execute(sqlQ)
+		return cursor.fetchone()
   
-  def get_config_list(self):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT id FROM configs WHERE default_config = False AND active = True'
-    cursor.execute(sqlQ)
-    return cursor.fetchall()
-
-  def get_config_list_all(self):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT id FROM configs'
-    cursor.execute(sqlQ)
-    return cursor.fetchall()
-
-  def update__make_conf(self, configsDict):
-    cursor = self.conn.cursor()
-    sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s'
-    for k, v in configsDict.iteritems():
-      params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
-      cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def have_package_db(self, categories, package):
-    cursor = self.conn.cursor()
-    sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s'
-    params = categories, package
-    cursor.execute(sqlQ, params)
-    return cursor.fetchone()
-
-  def get_categories_db(self):
-    cursor = self.conn.cursor()
-    sqlQ =' SELECT category FROM categories'
-    cursor.execute(sqlQ)
-    return cursor.fetchall()
-
-  def get_categories_checksum_db(self, categories):
-    cursor = self.conn.cursor()
-    sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s'
-    cursor.execute(sqlQ, (categories,))
-    return cursor.fetchone()
-
-  def add_new_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
-    cursor = self.conn.cursor()
-    sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES  ( %s, %s, %s )'
-    params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree
-    cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def update_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
-    cursor = self.conn.cursor()
-    sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s'
-    params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories)
-    cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def add_new_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
-    cursor = self.conn.cursor()
-    sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES  ( %s, %s, %s )'
-    params = package_id, get_manifest_text, manifest_checksum_tree
-    cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def add_new_package_metadata(self, package_id, package_metadataDict):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s'
-    cursor.execute(sqlQ, (package_id,))
-    if cursor.fetchone() is None:
-      sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES  ( %s, %s, %s, %s, %s )'
-      for k, v in package_metadataDict.iteritems():
-	params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum']
-	cursor.execute(sqlQ, params)
-      self.conn.commit()
-
-  def update_new_package_metadata(self, package_id, package_metadataDict):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s'
-    cursor.execute(sqlQ, package_id)
-    entries = cursor.fetchone()
-    changelog_checksum_db = entries[0]
-    metadata_checksum_db = entries[1]
-    for k, v in package_metadataDict.iteritems():
-      if changelog_checksum_db != v['changelog_checksum']:
-	sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s'
-	params = v['changelog_text'], v['changelog_checksum'], package_id
-	cursor.execute(sqlQ, params)
-      if metadata_checksum_db != v['metadata_xml_checksum']:
-	sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s'
-	params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id
-	cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def get_manifest_db(self, package_id):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s'
-    cursor.execute(sqlQ, (package_id,))
-    return cursor.fetchone()
-
-  def update_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
-   cursor = self.conn.cursor()
-   sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s'
-   params = (manifest_checksum_tree, get_manifest_text, package_id)
-   cursor.execute(sqlQ, params)
-   self.conn.commit()
-
-  def add_new_metadata(self, metadataDict):
-    for k, v in metadataDict.iteritems():
-      cursor = self.conn.cursor()
-      sqlQ = 'SELECT updaterestrictions( %s, %s )'
-      params = k, v['restrictions']
-      cursor.execute(sqlQ, params)
-      sqlQ = 'SELECT updatekeywords( %s, %s )'
-      params = k, v['keyword']
-      cursor.execute(sqlQ, params)
-      sqlQ = 'SELECT updateiuse( %s, %s )'
-      params = k, v['iuse']
-      cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def add_new_package_sql(self, packageDict):
-    #lets have a new cursor for each metod as per best practice
-    cursor = self.conn.cursor()
-    sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
-    ebuild_id_list = []
-    package_id_list = []
-    for k, v in packageDict.iteritems():
-      params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
-      v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
-      v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
-      v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
-      v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
-      v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-      v['ebuild_version_metadata_tree'][16]]
-      cursor.execute(sqlQ, params)
-      mid = cursor.fetchone()
-      mid=mid[0]
-      ebuild_id_list.append(mid[1])
-      package_id_list.append(mid[0])
-    self.conn.commit()
-    # add_new_metadata(metadataDict)
-    return ebuild_id_list, package_id_list
-
-  def add_new_ebuild_sql(packageDict, new_ebuild_list):
-    #lets have a new cursor for each metod as per best practice
-    cursor = self.conn.cursor()
-    sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
-    ebuild_id_list = []
-    package_id_list = []
-    for k, v in packageDict.iteritems():
-      for x in new_ebuild_list:
-	if x == v['ebuild_version_tree']:
-	  params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
-	  v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
-	  v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
-	  v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
-	  v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
-	  v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-	  v['ebuild_version_metadata_tree'][16]]
-	  cursor.execute(sqlQ, params)
-	  mid = cursor.fetchone()
-	  mid=mid[0]
-	  ebuild_id_list.append(mid[1])
-	  package_id_list.append(mid[0])
-    self.conn.commit()
-    # add_new_metadata(metadataDict)
-    return ebuild_id_list, package_id_list
-
-  def update_active_ebuild(self, package_id, ebuild_version_tree):
-    cursor = self.conn.cursor()
-    sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'"
-    cursor.execute(sqlQ, (package_id, ebuild_version_tree))
-    self.conn.commit()
-
-  def get_cpv_from_ebuild_id(self, ebuild_id):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s'
-    self.cursor.execute(sql, ebuild_id)
-    entries = self.cursor.fetchone()
-    return entries
-
-  def get_cp_from_package_id(self, package_id):
-    cursor = self.conn.cursor()
-    sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s"
-    cursor.execute(sqlQ, (package_id,))
-    return cursor.fetchone()
+	def get_config_list(self):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT id FROM configs WHERE default_config = False AND active = True'
+		cursor.execute(sqlQ)
+		return cursor.fetchall()
+
+	def get_config_list_all(self):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT id FROM configs'
+		cursor.execute(sqlQ)
+		return cursor.fetchall()
+
+	def update__make_conf(self, configsDict):
+		cursor = self.conn.cursor()
+		sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s'
+		for k, v in configsDict.iteritems():
+			params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
+			cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def have_package_db(self, categories, package):
+		cursor = self.conn.cursor()
+		sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s'
+		params = categories, package
+		cursor.execute(sqlQ, params)
+		return cursor.fetchone()
+
+	def get_categories_db(self):
+		cursor = self.conn.cursor()
+		sqlQ =' SELECT category FROM categories'
+		cursor.execute(sqlQ)
+		return cursor.fetchall()
+
+	def get_categories_checksum_db(self, categories):
+		cursor = self.conn.cursor()
+		sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s'
+		cursor.execute(sqlQ, (categories,))
+		return cursor.fetchone()
+
+	def add_new_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+		cursor = self.conn.cursor()
+		sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES  ( %s, %s, %s )'
+		params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree
+		cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def update_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+		cursor = self.conn.cursor()
+		sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s'
+		params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories)
+		cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def add_new_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
+		cursor = self.conn.cursor()
+		sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES  ( %s, %s, %s )'
+		params = package_id, get_manifest_text, manifest_checksum_tree
+		cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def add_new_package_metadata(self, package_id, package_metadataDict):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s'
+		cursor.execute(sqlQ, (package_id,))
+		if cursor.fetchone() is None:
+			sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES  ( %s, %s, %s, %s, %s )'
+			for k, v in package_metadataDict.iteritems():
+				params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum']
+				cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def update_new_package_metadata(self, package_id, package_metadataDict):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s'
+		cursor.execute(sqlQ, package_id)
+		entries = cursor.fetchone()
+		if entries is None:
+			changelog_checksum_db = None
+			metadata_checksum_db = None
+		else:
+			changelog_checksum_db = entries[0]
+			metadata_checksum_db = entries[1]
+		for k, v in package_metadataDict.iteritems():
+			if changelog_checksum_db != v['changelog_checksum']:
+				sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s'
+				params = v['changelog_text'], v['changelog_checksum'], package_id
+				cursor.execute(sqlQ, params)
+			if metadata_checksum_db != v['metadata_xml_checksum']:
+				sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s'
+				params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id
+				cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def get_manifest_db(self, package_id):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s'
+		cursor.execute(sqlQ, (package_id,))
+		manifest_checksum = cursor.fetchone()
+		if manifest_checksum is None:
+			return None
+		return manifest_checksum[0]
+
+	def update_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
+		cursor = self.conn.cursor()
+		sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s'
+		params = (manifest_checksum_tree, get_manifest_text, package_id)
+		cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def add_new_metadata(self, metadataDict):
+		for k, v in metadataDict.iteritems():
+			cursor = self.conn.cursor()
+			sqlQ = 'SELECT updaterestrictions( %s, %s )'
+			params = k, v['restrictions']
+			cursor.execute(sqlQ, params)
+			sqlQ = 'SELECT updatekeywords( %s, %s )'
+			params = k, v['keyword']
+			cursor.execute(sqlQ, params)
+			sqlQ = 'SELECT updateiuse( %s, %s )'
+			params = k, v['iuse']
+			cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def add_new_package_sql(self, packageDict):
+		#lets have a new cursor for each metod as per best practice
+		cursor = self.conn.cursor()
+		sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+		ebuild_id_list = []
+		package_id_list = []
+		for k, v in packageDict.iteritems():
+			params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+				v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+				v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+				v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+				v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+				v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+				v['ebuild_version_metadata_tree'][16]]
+			cursor.execute(sqlQ, params)
+			mid = cursor.fetchone()
+			mid=mid[0]
+			ebuild_id_list.append(mid[1])
+			package_id_list.append(mid[0])
+		self.conn.commit()
+		# add_new_metadata(metadataDict)
+		return ebuild_id_list, package_id_list
+
+	def add_new_ebuild_sql(packageDict, new_ebuild_list):
+		#lets have a new cursor for each metod as per best practice
+		cursor = self.conn.cursor()
+		sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+		ebuild_id_list = []
+		package_id_list = []
+		for k, v in packageDict.iteritems():
+			for x in new_ebuild_list:
+				if x == v['ebuild_version_tree']:
+					params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+						v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+						v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+						v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+						v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+						v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+						v['ebuild_version_metadata_tree'][16]]
+					cursor.execute(sqlQ, params)
+					mid = cursor.fetchone()
+					mid=mid[0]
+					ebuild_id_list.append(mid[1])
+					package_id_list.append(mid[0])
+		self.conn.commit()
+		# add_new_metadata(metadataDict)
+		return ebuild_id_list, package_id_list
+
+	def update_active_ebuild(self, package_id, ebuild_version_tree):
+		cursor = self.conn.cursor()
+		sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'"
+		cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+		self.conn.commit()
+
+	def get_cpv_from_ebuild_id(self, ebuild_id):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s'
+		self.cursor.execute(sql, ebuild_id)
+		entries = self.cursor.fetchone()
+		return entries
+
+	def get_cp_from_package_id(self, package_id):
+		cursor = self.conn.cursor()
+		sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s"
+		cursor.execute(sqlQ, (package_id,))
+		return cursor.fetchone()
   
-  def add_new_package_buildqueue(self, ebuild_id, config_id, iuse_flags_list, use_enable, message):
-    cursor = self.conn.cursor()
-    sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )"
-    if not iuse_flags_list:
-      iuse_flags_list=None
-      use_enable=None
-    params = ebuild_id, unicode(config_id), iuse_flags_list, use_enable, message
-    cursor.execute(sqlQ, params)
-    self.conn.commit()
-
-  def get_ebuild_checksum(self, package_id, ebuild_version_tree):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE'
-    cursor.execute(sqlQ, (package_id, ebuild_version_tree))
-    entries = cursor.fetchone()
-    if entries is None:
-      return None
-    return entries[0]
-
-  def add_old_package(self, old_package_list):
-    cursor = self.conn.cursor()
-    mark_old_list = []
-    sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id"
-    for old_package in old_package_list:
-      cursor.execute(sqlQ, (old_package[0],))
-      entries = cursor.fetchone()
-      if entries is not None:
-	mark_old_list.append(entries[0])
-    self.conn.commit()
-    return mark_old_list
+	def add_new_package_buildqueue(self, ebuild_id, config_id, iuse_flags_list, use_enable, message):
+		cursor = self.conn.cursor()
+		sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )"
+		if not iuse_flags_list:
+			iuse_flags_list=None
+			use_enable=None
+		params = ebuild_id, unicode(config_id), iuse_flags_list, use_enable, message
+		cursor.execute(sqlQ, params)
+		self.conn.commit()
+
+	def get_ebuild_checksum(self, package_id, ebuild_version_tree):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE'
+		cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+		entries = cursor.fetchone()
+		if entries is None:
+			return None
+		return entries[0]
+
+	def add_old_package(self, old_package_list):
+		cursor = self.conn.cursor()
+		mark_old_list = []
+		sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id"
+		for old_package in old_package_list:
+			cursor.execute(sqlQ, (old_package[0],))
+			entries = cursor.fetchone()
+		if entries is not None:
+			mark_old_list.append(entries[0])
+		self.conn.commit()
+		return mark_old_list
   
-  def get_old_categories(self, categories_line):
-    cursor = self.conn.cursor()
-    sqlQ = "SELECT package_name FROM packages WHERE category = %s"
-    cursor.execute(sqlQ (categories_line))
-    return cursor.fetchone()
-
-  def del_old_categories(self, real_old_categoriess):
-    cursor = self.conn.cursor()
-    sqlQ = 'DELETE FROM categories categories_meta WHERE category = %s'
-    cursor.execute(sqlQ (real_old_categories))
-    self.conn.commit()
-
-  def add_old_ebuild(self, package_id, old_ebuild_list):
-    cursor = self.conn.cursor()
-    sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s"
-    sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'"
-    sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s"
-    sqlQ4 = 'DELETE FROM ebuildqueuedwithuses buildqueue WHERE queue_id = %s'
-    for old_ebuild in  old_ebuild_list:
-      cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
-      ebuild_id_list = cursor.fetchall()
-      if ebuild_id_list is not None:
-	for ebuild_id in ebuild_id_list:
-	  cursor.execute(sqlQ3, (ebuild_id))
-	  queue_id_list = cursor.fetchall()
-	  if queue_id_list is not None:
-	    for queue_id in queue_id_list:
-	      cursor.execute(sqlQ4, (queue_id))
-      cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
-    self.conn.commit()
-
-  def cp_all_old_db(self, old_package_id_list):
-    cursor = self.conn.cursor()
-    old_package_list = []
-    for old_package in old_package_id_list:
-      sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60"
-      cursor.execute(sqlQ, old_package)
-      entries = cursor.fetchone()
-      if entries is None:
-	old_package_list.append(old_package)
-    return old_package_list
-  def cp_all_db(self):
-    cursor = self.conn.cursor()
-    sqlQ = "SELECT package_id FROM packages"
-    cursor.execute(sqlQ)
-    return cursor.fetchall()
-
-  def del_old_ebuild(self, ebuild_old_list_db):
-    cursor = self.conn.cursor()
-    sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
-    sqlQ3 = 'DELETE FROM qa_problems repoman_problems  WHERE build_id = %s'
-    sqlQ4 = 'DELETE FROM ebuildhaveskeywords ebuildhavesiuses WHERE ebuild_id = %s'
-    sqlQ5 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
-    sqlQ6 = 'DELETE FROM ebuildhavesrestrictions buildlog WHERE ebuild_id = %s'
-    for del_ebuild_old in ebuild_old_list_db:
-      cursor.execute(sqlQ2, (del_ebuild_old[0],))
-      build_id_list = cursor.fetchall()
-      for build_id in build_id_list:
-	cursor.execute(sqlQ3, (build_id,))
-	cursor.execute(sqlQ5, (build_id,))
-      cursor.execute(sqlQ4, (del_ebuild_old[0],))
-      cursor.execute(sqlQ6, (del_ebuild_old[0],))
-    self.conn.commit()
-
-  def del_old_package(self, package_id_list):
-    cursor = self.conn.cursor()
-    sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s'
-    sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
-    sqlQ3 = 'DELETE FROM qa_problems, repoman_problems, ebuildbuildwithuses WHERE build_id = %s'
-    sqlQ4 = 'DELETE FROM ebuildhaveskeywords, ebuildhavesiuses, ebuildhavesrestrictions, buildlog WHERE ebuild_id = %s'
-    sqlQ5 = 'DELETE FROM ebuilds, manifest, package_meta, packages WHERE package_id = %s'
-    for package_id in package_id_list:
-      cursor.execute(sqlQ1, package_id)
-      ebuild_id_list = cursor.fetchall()
-      for ebuild_id in ebuild_id_list:
-	cursor.execute(sqlQ2, ebuild_id)
-	build_id_list = cursor.fetchall()
-	for build_id in build_id_list:
-	  cursor.execute(sqlQ3, build_id)
-	cursor.execute(sqlQ4, ebuild_id)
-      cursor.execute(sqlQ5, package_id)
-    self.conn.commit()
-
-  def cp_list_db(self, package_id):
-    cursor = self.conn.cursor()
-    sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s"
-    cursor.execute(sqlQ, (package_id))
-    return cursor.fetchall()
-
-  def cp_list_old_db(self, package_id):
-    cursor = self.conn.cursor()
-    sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60"
-    cursor.execute(sqlQ, package_id)
-    return cursor.fetchall()
-
-  def add_qa_repoman(self, ebuild_id_list, qa_error, packageDict, config_id):
-    ebuild_i = 0
-    cursor = self.conn.cursor()
-    for k, v in packageDict.iteritems():
-      ebuild_id = ebuild_id_list[ebuild_i]
-      sqlQ = 'INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp ) VALUES  ( %s, %s, %s, now() ) RETURNING build_id'
-      if v['ebuild_error'] != [] or qa_error != []:
-	if v['ebuild_error'] != [] or qa_error == []:
-	  summary = "Repoman"
-	elif v['ebuild_error'] == [] or qa_error != []:
-	  summary = "QA"
-	else:
-	  summary = "QA:Repoman"
-	params = (ebuild_id, config_id, summary)
-	cursor.execute(sqlQ, params)
-	build_id = cursor.fetchone()
-	if v['ebuild_error'] != []:
-	  sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
-	  for x in v['ebuild_error']:
-	    params = (x, build_id)
-	    cursor.execute(sqlQ, params)
-	if qa_error != []:
-	  sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
-	  for x in qa_error:
-	    params = (x, build_id)
-	    cursor.execute(sqlQ, params)
-      ebuild_i = ebuild_i +1
-    self.conn.commit()
-
-  def get_arch_db(self):
-    cursor = self.conn.cursor()
-    sqlQ = 'SELECT keyword FROM keywords WHERE keyword = %s'
-    cursor.execute(sqlQ, ('ppc',))
-    return cursor.fetchone()
+	def get_old_categories(self, categories_line):
+		cursor = self.conn.cursor()
+		sqlQ = "SELECT package_name FROM packages WHERE category = %s"
+		cursor.execute(sqlQ (categories_line))
+		return cursor.fetchone()
+
+	def del_old_categories(self, real_old_categoriess):
+		cursor = self.conn.cursor()
+		sqlQ1 = 'DELETE FROM categories_meta WHERE category = %s'
+		sqlQ2 = 'DELETE FROM categories categories_meta WHERE category = %s'
+		cursor.execute(sqlQ1 (real_old_categories))
+		cursor.execute(sqlQ2 (real_old_categories))
+		self.conn.commit()
+
+	def add_old_ebuild(self, package_id, old_ebuild_list):
+		cursor = self.conn.cursor()
+		sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s"
+		sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'"
+		sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s"
+		sqlQ4 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+		sqlQ5 = 'DELETE FROM buildqueue WHERE queue_id = %s'
+		for old_ebuild in  old_ebuild_list:
+			cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
+			ebuild_id_list = cursor.fetchall()
+			if ebuild_id_list is not None:
+				for ebuild_id in ebuild_id_list:
+					cursor.execute(sqlQ3, (ebuild_id))
+					queue_id_list = cursor.fetchall()
+					if queue_id_list is not None:
+						for queue_id in queue_id_list:
+							cursor.execute(sqlQ4, (queue_id))
+							cursor.execute(sqlQ5, (queue_id))
+			cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
+		self.conn.commit()
+
+	def cp_all_old_db(self, old_package_id_list):
+		cursor = self.conn.cursor()
+		old_package_list = []
+		for old_package in old_package_id_list:
+			sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60"
+			cursor.execute(sqlQ, old_package)
+			entries = cursor.fetchone()
+			if entries is None:
+				old_package_list.append(old_package)
+		return old_package_list
+
+	def cp_all_db(self):
+		cursor = self.conn.cursor()
+		sqlQ = "SELECT package_id FROM packages"
+		cursor.execute(sqlQ)
+		return cursor.fetchall()
+
+	def del_old_ebuild(self, ebuild_old_list_db):
+		cursor = self.conn.cursor()
+		sqlQ1 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+		sqlQ2 = 'DELETE FROM qa_problems WHERE build_id = %s'
+		sqlQ3 = 'DELETE FROM repoman_problems WHERE build_id = %s'
+		sqlQ4 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
+		sqlQ5 = 'DELETE FROM ebuildhaveskeywords WHERE ebuild_id = %s'
+		sqlQ6 = 'DELETE FROM ebuildhavesiuses WHERE ebuild_id = %s'
+		sqlQ7 = 'DELETE FROM ebuildhavesrestrictions WHERE ebuild_id = %s'
+		sqlQ8 = 'DELETE FROM buildlog WHERE ebuild_id = %s'
+		sqlQ9 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s'
+		sqlQ10 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+		sqlQ11 = 'DELETE FROM buildqueue WHERE ebuild_id  = %s'
+		sqlQ12 = 'DELETE FROM ebuilds WHERE id  = %s'
+		for ebuild_id in ebuild_old_list_db:
+			cursor.execute(sqlQ1, (ebuild_id[0],))
+			build_id_list = cursor.fetchall()
+			for build_id in build_id_list:
+				cursor.execute(sqlQ2, (build_id,))
+				cursor.execute(sqlQ3, (build_id,))
+				cursor.execute(sqlQ4, (build_id,))
+			cursor.execute(sqlQ9, (ebuild_id[0],))
+			queue_id_list = cursor.fetchall()
+			for queue_id in queue_id_list:
+				cursor.execute(sqlQ10, (queue_id,))
+			cursor.execute(sqlQ5, (ebuild_id[0],))
+			cursor.execute(sqlQ6, (ebuild_id[0],))
+			cursor.execute(sqlQ7, (ebuild_id[0],))
+			cursor.execute(sqlQ8, (ebuild_id[0],))
+			cursor.execute(sqlQ11, (ebuild_id[0],))
+			cursor.execute(sqlQ12, (ebuild_id[0],))
+		self.conn.commit()
+
+	def del_old_package(self, package_id_list):
+		cursor = self.conn.cursor()
+		sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s'
+		sqlQ2 = 'DELETE FROM ebuilds WHERE package_id = %s'
+		sqlQ3 = 'DELETE FROM manifest WHERE package_id = %s'
+		sqlQ4 = 'DELETE FROM packages_meta WHERE package_id = %s'
+		sqlQ5 = 'DELETE FROM packages WHERE package_id = %s'
+		for package_id in package_id_list:
+			cursor.execute(sqlQ1, package_id)
+			ebuild_id_list = cursor.fetchall()
+			self.del_old_ebuild(ebuild_id_list)
+			cursor.execute(sqlQ2, (package_id,))
+			cursor.execute(sqlQ3, (package_id,))
+			cursor.execute(sqlQ4, (package_id,))
+			cursor.execute(sqlQ5, (package_id,))
+		self.conn.commit()
+
+	def cp_list_db(self, package_id):
+		cursor = self.conn.cursor()
+		sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s"
+		cursor.execute(sqlQ, (package_id))
+		return cursor.fetchall()
+
+	def cp_list_old_db(self, package_id):
+		cursor = self.conn.cursor()
+		sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60"
+		cursor.execute(sqlQ, package_id)
+		return cursor.fetchall()
+
+	def add_qa_repoman(self, ebuild_id_list, qa_error, packageDict, config_id):
+		ebuild_i = 0
+		cursor = self.conn.cursor()
+		for k, v in packageDict.iteritems():
+			ebuild_id = ebuild_id_list[ebuild_i]
+			sqlQ = "INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp, hash ) VALUES  ( %s, %s, %s, now(), '0' ) RETURNING build_id"
+			if v['ebuild_error'] != [] or qa_error != []:
+				if v['ebuild_error'] != [] or qa_error == []:
+					summary = "Repoman"
+				elif v['ebuild_error'] == [] or qa_error != []:
+					summary = "QA"
+				else:
+					summary = "QA:Repoman"
+				params = (ebuild_id, config_id, summary)
+				cursor.execute(sqlQ, params)
+				build_id = cursor.fetchone()
+				if v['ebuild_error'] != []:
+					sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
+					for x in v['ebuild_error']:
+						params = (x, build_id)
+						cursor.execute(sqlQ, params)
+					if qa_error != []:
+						sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
+						for x in qa_error:
+							params = (x, build_id)
+							cursor.execute(sqlQ, params)
+			ebuild_i = ebuild_i +1
+		self.conn.commit()
+
+	def get_arch_db(self):
+		cursor = self.conn.cursor()
+		sqlQ = 'SELECT keyword FROM keywords WHERE keyword = %s'
+		cursor.execute(sqlQ, ('ppc',))
+		return cursor.fetchone()
   
-  def add_new_arch_db(self, arch_list):
-    cursor = self.conn.cursor()
-    sqlQ = 'INSERT INTO keywords (keyword) VALUES  ( %s )'
-    for arch in arch_list:
-      cursor.execute(sqlQ, (arch,))
-    self.conn.commit()
-
-  def closeconnection(self):
-    self.conn.close()
+	def add_new_arch_db(self, arch_list):
+		cursor = self.conn.cursor()
+		sqlQ = 'INSERT INTO keywords (keyword) VALUES  ( %s )'
+		for arch in arch_list:
+			cursor.execute(sqlQ, (arch,))
+		self.conn.commit()
+
+	def closeconnection(self):
+		self.conn.close()
 
 class PgSQLPackageDB(SQLPackageDatabase):
 	"""override for MySQL backend"""