/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to shamap.py

Partially fix pull.

Show diffs side-by-side

added added

removed removed

Lines of Context:
shamap.py
1
 
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
 
1
# Copyright (C) 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Map from Git sha's to Bazaar objects."""
18
18
 
 
19
import bzrlib
 
20
 
 
21
from bzrlib.errors import NoSuchRevision
 
22
 
19
23
import os
20
24
 
21
 
import bzrlib
22
 
from bzrlib.errors import (
23
 
    NoSuchRevision,
24
 
    )
25
 
 
26
25
 
27
26
def check_pysqlite_version(sqlite3):
28
27
    """Check that sqlite library is compatible.
48
47
 
49
48
 
50
49
class GitShaMap(object):
51
 
    """Git<->Bzr revision id mapping database."""
52
 
 
53
 
    def add_entry(self, sha, type, type_data):
54
 
        """Add a new entry to the database.
55
 
        """
56
 
        raise NotImplementedError(self.add_entry)
57
 
 
58
 
    def lookup_tree(self, path, revid):
59
 
        """Lookup the SHA of a git tree."""
60
 
        raise NotImplementedError(self.lookup_tree)
61
 
 
62
 
    def lookup_blob(self, fileid, revid):
63
 
        raise NotImplementedError(self.lookup_blob)
64
 
 
65
 
    def lookup_git_sha(self, sha):
66
 
        """Lookup a Git sha in the database.
67
 
 
68
 
        :param sha: Git object sha
69
 
        :return: (type, type_data) with type_data:
70
 
            revision: revid, tree sha
71
 
        """
72
 
        raise NotImplementedError(self.lookup_git_sha)
73
 
 
74
 
    def revids(self):
75
 
        """List the revision ids known."""
76
 
        raise NotImplementedError(self.revids)
77
 
 
78
 
    def commit(self):
79
 
        """Commit any pending changes."""
80
 
 
81
 
 
82
 
class DictGitShaMap(GitShaMap):
83
 
 
84
 
    def __init__(self):
85
 
        self.dict = {}
86
 
 
87
 
    def add_entry(self, sha, type, type_data):
88
 
        self.dict[sha] = (type, type_data)
89
 
 
90
 
    def lookup_git_sha(self, sha):
91
 
        return self.dict[sha]
92
 
 
93
 
    def lookup_tree(self, path, revid):
94
 
        for k, v in self.dict.iteritems():
95
 
            if v == ("tree", (path, revid)):
96
 
                return k
97
 
        raise KeyError((path, revid))
98
 
 
99
 
    def lookup_blob(self, fileid, revid):
100
 
        for k, v in self.dict.iteritems():
101
 
            if v == ("blob", (fileid, revid)):
102
 
                return k
103
 
        raise KeyError((fileid, revid))
104
 
 
105
 
    def revids(self):
106
 
        for key, (type, type_data) in self.dict.iteritems():
107
 
            if type == "commit":
108
 
                yield type_data[0]
109
 
 
110
 
 
111
 
class SqliteGitShaMap(GitShaMap):
112
 
 
113
 
    def __init__(self, transport=None):
 
50
 
 
51
    def __init__(self, transport):
114
52
        self.transport = transport
115
 
        if transport is None:
116
 
            self.db = sqlite3.connect(":memory:")
117
 
        else:
118
 
            self.db = sqlite3.connect(
119
 
                os.path.join(self.transport.local_abspath("."), "git.db"))
 
53
        self.db = sqlite3.connect(
 
54
            os.path.join(self.transport.local_abspath("."), "git.db"))
120
55
        self.db.executescript("""
121
56
        create table if not exists commits(sha1 text, revid text, tree_sha text);
122
57
        create index if not exists commit_sha1 on commits(sha1);
123
 
        create unique index if not exists commit_revid on commits(revid);
124
58
        create table if not exists blobs(sha1 text, fileid text, revid text);
125
59
        create index if not exists blobs_sha1 on blobs(sha1);
126
 
        create unique index if not exists blobs_fileid_revid on blobs(fileid, revid);
127
 
        create table if not exists trees(sha1 text, path text, revid text);
 
60
        create table if not exists trees(sha1 text, fileid text, revid text);
128
61
        create index if not exists trees_sha1 on trees(sha1);
129
 
        create unique index if not exists trees_path_revid on trees(path, revid);
130
62
""")
131
63
 
132
64
    def _parent_lookup(self, revid):
133
65
        return self.db.execute("select sha1 from commits where revid = ?", (revid,)).fetchone()[0].encode("utf-8")
134
66
 
135
 
    def commit(self):
136
 
        self.db.commit()
137
 
 
138
67
    def add_entry(self, sha, type, type_data):
139
68
        """Add a new entry to the database.
140
69
        """
145
74
        elif type == "blob":
146
75
            self.db.execute("replace into blobs (sha1, fileid, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
147
76
        elif type == "tree":
148
 
            self.db.execute("replace into trees (sha1, path, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
 
77
            self.db.execute("replace into trees (sha1, fileid, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
149
78
        else:
150
79
            raise AssertionError("Unknown type %s" % type)
151
80
 
152
 
    def lookup_tree(self, path, revid):
153
 
        row = self.db.execute("select sha1 from trees where path = ? and revid = ?", (path,revid)).fetchone()
154
 
        if row is None:
155
 
            raise KeyError((path, revid))
156
 
        return row[0]
157
 
 
158
 
    def lookup_blob(self, fileid, revid):
159
 
        row = self.db.execute("select sha1 from blobs where fileid = ? and revid = ?", (fileid, revid)).fetchone()
160
 
        if row is None:
161
 
            raise KeyError((fileid, revid))
162
 
        return row[0]
163
 
 
164
81
    def lookup_git_sha(self, sha):
165
82
        """Lookup a Git sha in the database.
166
83
 
174
91
        row = self.db.execute("select fileid, revid from blobs where sha1 = ?", (sha,)).fetchone()
175
92
        if row is not None:
176
93
            return ("blob", row)
177
 
        row = self.db.execute("select path, revid from trees where sha1 = ?", (sha,)).fetchone()
 
94
        row = self.db.execute("select fileid, revid from trees where sha1 = ?", (sha,)).fetchone()
178
95
        if row is not None:
179
96
            return ("tree", row)
180
97
        raise KeyError(sha)
181
98
 
182
99
    def revids(self):
183
 
        """List the revision ids known."""
184
100
        for row in self.db.execute("select revid from commits").fetchall():
185
101
            yield row[0]