updated portage to 2.2.8-r1HEADmaster

1 files changed, 57 insertions, 23 deletions

diff --git a/portage_with_autodep/pym/portage/cache/sqlite.py b/portage_with_autodep/pym/portage/cache/sqlite.py
index fcc62ff..40db070 100644
--- a/portage_with_autodep/pym/portage/cache/sqlite.py
+++ b/portage_with_autodep/pym/portage/cache/sqlite.py
@@ -1,6 +1,9 @@
-# Copyright 1999-2011 Gentoo Foundation
+# Copyright 1999-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
+import re
 import sys
 from portage.cache import fs_template
 from portage.cache import cache_errors
@@ -20,7 +23,6 @@ class database(fs_template.FsBased):
 	# to calculate the number of pages requested, according to the following
 	# equation: cache_bytes = page_bytes * page_count
 	cache_bytes = 1024 * 1024 * 10
-	_db_table = None
 
 	def __init__(self, *args, **config):
 		super(database, self).__init__(*args, **config)
@@ -28,6 +30,7 @@ class database(fs_template.FsBased):
 		self._allowed_keys = ["_mtime_", "_eclasses_"]
 		self._allowed_keys.extend(self._known_keys)
 		self._allowed_keys.sort()
+		self._allowed_keys_set = frozenset(self._allowed_keys)
 		self.location = os.path.join(self.location, 
 			self.label.lstrip(os.path.sep).rstrip(os.path.sep))
 
@@ -37,8 +40,8 @@ class database(fs_template.FsBased):
 		config.setdefault("autocommit", self.autocommits)
 		config.setdefault("cache_bytes", self.cache_bytes)
 		config.setdefault("synchronous", self.synchronous)
-		# Timeout for throwing a "database is locked" exception (pysqlite
-		# default is 5.0 seconds).
+		# Set longer timeout for throwing a "database is locked" exception.
+		# Default timeout in sqlite3 module is 5.0 seconds.
 		config.setdefault("timeout", 15)
 		self._db_init_connection(config)
 		self._db_init_structures()
@@ -47,11 +50,8 @@ class database(fs_template.FsBased):
 		# sqlite3 is optional with >=python-2.5
 		try:
 			import sqlite3 as db_module
-		except ImportError:
-			try:
-				from pysqlite2 import dbapi2 as db_module
-			except ImportError as e:
-				raise cache_errors.InitializationError(self.__class__, e)
+		except ImportError as e:
+			raise cache_errors.InitializationError(self.__class__, e)
 
 		self._db_module = db_module
 		self._db_error = db_module.Error
@@ -62,7 +62,6 @@ class database(fs_template.FsBased):
 			# Avoid potential UnicodeEncodeError in python-2.x by
 			# only calling str() when it's absolutely necessary.
 			s = str(s)
-		# This is equivalent to the _quote function from pysqlite 1.1.
 		return "'%s'" % s.replace("'", "''")
 
 	def _db_init_connection(self, config):
@@ -92,9 +91,6 @@ class database(fs_template.FsBased):
 		self._db_table["packages"]["table_name"] = mytable
 		self._db_table["packages"]["package_id"] = "internal_db_package_id"
 		self._db_table["packages"]["package_key"] = "portage_package_key"
-		self._db_table["packages"]["internal_columns"] = \
-			[self._db_table["packages"]["package_id"],
-			self._db_table["packages"]["package_key"]]
 		create_statement = []
 		create_statement.append("CREATE TABLE")
 		create_statement.append(mytable)
@@ -109,15 +105,18 @@ class database(fs_template.FsBased):
 		create_statement.append(")")
 		
 		self._db_table["packages"]["create"] = " ".join(create_statement)
-		self._db_table["packages"]["columns"] = \
-			self._db_table["packages"]["internal_columns"] + \
-			self._allowed_keys
 
 		cursor = self._db_cursor
 		for k, v in self._db_table.items():
 			if self._db_table_exists(v["table_name"]):
 				create_statement = self._db_table_get_create(v["table_name"])
-				if create_statement != v["create"]:
+				table_ok, missing_keys = self._db_validate_create_statement(create_statement)
+				if table_ok:
+					if missing_keys:
+						for k in sorted(missing_keys):
+							cursor.execute("ALTER TABLE %s ADD COLUMN %s TEXT" %
+								(self._db_table["packages"]["table_name"], k))
+				else:
 					writemsg(_("sqlite: dropping old table: %s\n") % v["table_name"])
 					cursor.execute("DROP TABLE %s" % v["table_name"])
 					cursor.execute(v["create"])
@@ -138,6 +137,37 @@ class database(fs_template.FsBased):
 			self._db_escape_string(table_name))
 		return cursor.fetchall()[0][0]
 
+	def _db_validate_create_statement(self, statement):
+		missing_keys = None
+		if statement == self._db_table["packages"]["create"]:
+			return True, missing_keys
+
+		m = re.match(r'^\s*CREATE\s*TABLE\s*%s\s*\(\s*%s\s*INTEGER\s*PRIMARY\s*KEY\s*AUTOINCREMENT\s*,(.*)\)\s*$' %
+			(self._db_table["packages"]["table_name"],
+			self._db_table["packages"]["package_id"]),
+			statement)
+		if m is None:
+			return False, missing_keys
+
+		unique_constraints = set([self._db_table["packages"]["package_key"]])
+		missing_keys = set(self._allowed_keys)
+		unique_re = re.compile(r'^\s*UNIQUE\s*\(\s*(\w*)\s*\)\s*$')
+		column_re = re.compile(r'^\s*(\w*)\s*TEXT\s*$')
+		for x in m.group(1).split(","):
+			m = column_re.match(x)
+			if m is not None:
+				missing_keys.discard(m.group(1))
+				continue
+			m = unique_re.match(x)
+			if m is not None:
+				unique_constraints.discard(m.group(1))
+				continue
+
+		if unique_constraints:
+			return False, missing_keys
+
+		return True, missing_keys
+
 	def _db_init_cache_size(self, cache_bytes):
 		cursor = self._db_cursor
 		cursor.execute("PRAGMA page_size")
@@ -173,13 +203,17 @@ class database(fs_template.FsBased):
 			raise KeyError(cpv)
 		else:
 			raise cache_errors.CacheCorruption(cpv, "key is not unique")
+		result = result[0]
 		d = {}
-		internal_columns = self._db_table["packages"]["internal_columns"]
-		column_index = -1
-		for k in self._db_table["packages"]["columns"]:
-			column_index +=1
-			if k not in internal_columns:
-				d[k] = result[0][column_index]
+		allowed_keys_set = self._allowed_keys_set
+		for column_index, column_info in enumerate(cursor.description):
+			k = column_info[0]
+			if k in allowed_keys_set:
+				v = result[column_index]
+				if v is None:
+					# This happens after a new empty column has been added.
+					v = ""
+				d[k] = v
 
 		return d