/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

Add test for nick.

Show diffs side-by-side

added added

removed removed

Lines of Context:
shamap.py
1
 
# Copyright (C) 2009 Canonical Ltd
 
1
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
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 os
 
20
 
19
21
import bzrlib
20
 
 
21
 
from bzrlib.errors import NoSuchRevision
22
 
 
23
 
import os
 
22
from bzrlib.errors import (
 
23
    NoSuchRevision,
 
24
    )
24
25
 
25
26
 
26
27
def check_pysqlite_version(sqlite3):
47
48
 
48
49
 
49
50
class GitShaMap(object):
50
 
 
51
 
    def __init__(self, transport):
 
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_git_sha(self, sha):
 
63
        """Lookup a Git sha in the database.
 
64
 
 
65
        :param sha: Git object sha
 
66
        :return: (type, type_data) with type_data:
 
67
            revision: revid, tree sha
 
68
        """
 
69
        raise NotImplementedError(self.lookup_git_sha)
 
70
 
 
71
    def revids(self):
 
72
        """List the revision ids known."""
 
73
        raise NotImplementedError(self.revids)
 
74
 
 
75
    def commit(self):
 
76
        """Commit any pending changes."""
 
77
 
 
78
 
 
79
class DictGitShaMap(GitShaMap):
 
80
 
 
81
    def __init__(self):
 
82
        self.dict = {}
 
83
 
 
84
    def add_entry(self, sha, type, type_data):
 
85
        self.dict[sha] = (type, type_data)
 
86
 
 
87
    def lookup_git_sha(self, sha):
 
88
        return self.dict[sha]
 
89
 
 
90
    def lookup_tree(self, path, revid):
 
91
        for k, v in self.dict.iteritems():
 
92
            if v == ("tree", (path, revid)):
 
93
                return k
 
94
        raise KeyError((path, revid))
 
95
 
 
96
    def revids(self):
 
97
        for key, (type, type_data) in self.dict.iteritems():
 
98
            if type == "commit":
 
99
                yield type_data[0]
 
100
 
 
101
 
 
102
class SqliteGitShaMap(GitShaMap):
 
103
 
 
104
    def __init__(self, transport=None):
52
105
        self.transport = transport
53
 
        self.db = sqlite3.connect(
54
 
            os.path.join(self.transport.local_abspath("."), "git.db"))
 
106
        if transport is None:
 
107
            self.db = sqlite3.connect(":memory:")
 
108
        else:
 
109
            self.db = sqlite3.connect(
 
110
                os.path.join(self.transport.local_abspath("."), "git.db"))
55
111
        self.db.executescript("""
56
112
        create table if not exists commits(sha1 text, revid text, tree_sha text);
57
113
        create index if not exists commit_sha1 on commits(sha1);
 
114
        create unique index if not exists commit_revid on commits(revid);
58
115
        create table if not exists blobs(sha1 text, fileid text, revid text);
59
116
        create index if not exists blobs_sha1 on blobs(sha1);
60
 
        create table if not exists trees(sha1 text, fileid text, revid text);
 
117
        create unique index if not exists blobs_fileid_revid on blobs(fileid, revid);
 
118
        create table if not exists trees(sha1 text, path text, revid text);
61
119
        create index if not exists trees_sha1 on trees(sha1);
 
120
        create unique index if not exists trees_path_revid on trees(path, revid);
62
121
""")
63
122
 
64
123
    def _parent_lookup(self, revid):
65
124
        return self.db.execute("select sha1 from commits where revid = ?", (revid,)).fetchone()[0].encode("utf-8")
66
125
 
 
126
    def commit(self):
 
127
        self.db.commit()
 
128
 
67
129
    def add_entry(self, sha, type, type_data):
68
130
        """Add a new entry to the database.
69
131
        """
74
136
        elif type == "blob":
75
137
            self.db.execute("replace into blobs (sha1, fileid, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
76
138
        elif type == "tree":
77
 
            self.db.execute("replace into trees (sha1, fileid, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
 
139
            self.db.execute("replace into trees (sha1, path, revid) values (?, ?, ?)", (sha, type_data[0], type_data[1]))
78
140
        else:
79
141
            raise AssertionError("Unknown type %s" % type)
80
142
 
 
143
    def lookup_tree(self, path, revid):
 
144
        row = self.db.execute("select sha1 from trees where path = ? and revid = ?", (path,revid)).fetchone()
 
145
        if row is None:
 
146
            raise KeyError((path, revid))
 
147
        return row[0]
 
148
 
81
149
    def lookup_git_sha(self, sha):
82
150
        """Lookup a Git sha in the database.
83
151
 
91
159
        row = self.db.execute("select fileid, revid from blobs where sha1 = ?", (sha,)).fetchone()
92
160
        if row is not None:
93
161
            return ("blob", row)
94
 
        row = self.db.execute("select fileid, revid from trees where sha1 = ?", (sha,)).fetchone()
 
162
        row = self.db.execute("select path, revid from trees where sha1 = ?", (sha,)).fetchone()
95
163
        if row is not None:
96
164
            return ("tree", row)
97
165
        raise KeyError(sha)
98
166
 
99
167
    def revids(self):
 
168
        """List the revision ids known."""
100
169
        for row in self.db.execute("select revid from commits").fetchall():
101
170
            yield row[0]