| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| from __future__ import division, with_statement |
| |
| import datetime |
| import logging |
| import re |
| import sqlite3 |
| import unicodedata |
| |
| |
| class Error(Exception): |
| def __init__(self, msg, *args, **kwargs): |
| action = kwargs.pop("action", None) |
| if action is not None: |
| msg = "%s %s" % (NodeRev._opname(action), msg) |
| super(Error, self).__init__(msg, *args, **kwargs) |
| |
| |
| class SQLclass(object): |
| """Named index of SQL schema definitions and statements. |
| |
| Parses "schema.sql" and creates a class-level attribute for each |
| script and statement in that file. |
| """ |
| |
| def __init__(self): |
| import cStringIO |
| import pkgutil |
| |
| comment_rx = re.compile(r"\s*--.*$") |
| header_rx = re.compile(r"^---(?P<kind>STATEMENT|SCRIPT)" |
| r"\s+(?P<name>[_A-Z]+)$") |
| |
| kind = None |
| name = None |
| content = None |
| |
| def record_current_statement(): |
| if name is not None: |
| if kind == "SCRIPT": |
| self.__record_script(name, content.getvalue()) |
| else: |
| self.__record_statement(name, content.getvalue()) |
| |
| schema = cStringIO.StringIO(pkgutil.get_data(__name__, "schema.sql")) |
| for line in schema: |
| line = line.rstrip() |
| if not line: |
| continue |
| |
| header = header_rx.match(line) |
| if header: |
| record_current_statement() |
| kind = header.group("kind") |
| name = header.group("name") |
| content = cStringIO.StringIO() |
| continue |
| |
| line = comment_rx.sub("", line) |
| if not line: |
| continue |
| |
| if content is not None: |
| content.write(line) |
| content.write("\n") |
| record_current_statement() |
| |
| class __statement(object): |
| __slots__ = ("execute", "query") |
| def __init__(self, sql, query): |
| self.execute = sql._execute |
| self.query = query |
| |
| def __call__(self, cursor, **kwargs): |
| if len(kwargs): |
| return self.execute(cursor, self.query, kwargs) |
| return self.execute(cursor, self.query) |
| |
| def __record_statement(self, name, statement): |
| setattr(self, name, self.__statement(self, statement)) |
| |
| class __script(object): |
| __slots__ = ("execute", "query") |
| def __init__(self, sql, query): |
| self.execute = sql._executescript |
| self.query = query |
| |
| def __call__(self, cursor): |
| return self.execute(cursor, self.query) |
| |
| def __record_script(self, name, script): |
| setattr(self, name, self.__script(self, script)) |
| |
| LOGLEVEL = (logging.NOTSET + logging.DEBUG) // 2 |
| if logging.getLevelName(LOGLEVEL) == 'Level %s' % LOGLEVEL: |
| logging.addLevelName(LOGLEVEL, 'SQL') |
| |
| def _log(self, *args, **kwargs): |
| return logging.log(self.LOGLEVEL, *args, **kwargs) |
| |
| __stmt_param_rx = re.compile(r':([a-z]+)') |
| def _execute(self, cursor, statement, parameters=None): |
| if parameters is not None: |
| fmt = statement.replace("%", "%%") |
| fmt = self.__stmt_param_rx.sub(r'%(\1)r', fmt) |
| self._log("EXECUTE: " + fmt, parameters) |
| return cursor.execute(statement, parameters) |
| else: |
| self._log("EXECUTE: %s", statement) |
| return cursor.execute(statement) |
| |
| def _executescript(self, cursor, script): |
| self._log("EXECUTE: %s", script) |
| return cursor.executescript(script) |
| SQL = SQLclass() |
| |
| |
| class SQLobject(dict): |
| """Base for ORM abstractions.""" |
| |
| def __init__(self, **kwargs): |
| super(SQLobject, self).__init__(**kwargs) |
| for name in self._columns: |
| super(SQLobject, self).setdefault(name, None) |
| |
| def __getattr__(self, name): |
| return self.__getitem__(name) |
| |
| def __setattr__(self, name, value): |
| return self.__setitem__(name, value) |
| |
| def __delattr__(self, name): |
| return self.__delitem__(name) |
| |
| def _put(self, _cursor): |
| self._put_statement(_cursor, **self) |
| if self.id is None: |
| self.id = _cursor.lastrowid |
| else: |
| assert self.id == _cursor.lastrowid |
| |
| @classmethod |
| def _get(self, _cursor, pkey): |
| self._get_statement(_cursor, id=pkey) |
| return cls._from_row(_cursor.fetchone()) |
| |
| @classmethod |
| def _from_row(cls, row): |
| if row is not None: |
| return cls(**row) |
| return None |
| |
| def _clone(self): |
| return self.__class__(**self) |
| |
| |
| class Txn(SQLobject): |
| """O/R mapping for the "txn" table.""" |
| |
| _columns = ("id", "treeid", "revision", "created", "author", "state") |
| _put_statement = SQL.TXN_INSERT |
| _get_statement = SQL.TXN_GET |
| |
| # state |
| TRANSIENT = "T" |
| PERMANENT = "P" |
| DEAD = "D" |
| |
| def __init__(self, **kwargs): |
| super(Txn, self).__init__(**kwargs) |
| if self.state is None: |
| self.state = self.TRANSIENT |
| |
| def __str__(self): |
| return "%d/%d %c %s" % (self.revision, self.treeid, |
| self.state, self.created) |
| |
| @property |
| def _committed(self): |
| return self.state == self.PERMANENT |
| |
| @property |
| def _uncommitted(self): |
| return self.state == self.TRANSIENT |
| |
| @property |
| def _dead(self): |
| return self.state == self.DEAD |
| |
| @staticmethod |
| def _now(): |
| now = datetime.datetime.utcnow() |
| return (now.strftime("%Y%m%dT%H%M%S.%%03dZ") |
| % ((now.microsecond + 500) // 1000)) |
| |
| def _put(self, cursor): |
| if self.created is None: |
| self.created = self._now() |
| super(Txn, self)._put(cursor) |
| if self.treeid is None: |
| self.treeid = self.id |
| |
| @classmethod |
| def _find_newest(cls, cursor): |
| SQL.TXN_FIND_NEWEST(cursor) |
| return cls._from_row(cursor.fetchone()) |
| |
| @classmethod |
| def _find_by_revision(cls, cursor, revision): |
| SQL.TXN_FIND_BY_REVISION(cursor, revision = revision) |
| return cls._from_row(cursor.fetchone()) |
| |
| @classmethod |
| def _find_by_revision_timestamp(cls, cursor, revision, created): |
| SQL.TXN_FIND_BY_REVISION_AND_TIMESTAMP( |
| cursor, revision = revision, created = creted) |
| return cls._from_row(cursor.fetchone()) |
| |
| def _commit(self, cursor, revision): |
| assert self._uncommitted |
| now = self._now() |
| SQL.TXN_COMMIT(cursor, id = self.id, |
| revision = revision, created = now) |
| self.revision = revision |
| self.created = now |
| self.state = self.PERMANENT |
| |
| def _abort(self, cursor): |
| assert self._uncommitted |
| SQL.TXN_ABORT(cursor, id = self.id) |
| self.state = self.DEAD |
| |
| def _cleanup(self, cursor): |
| assert self._dead |
| SQL.TXN_CLEANUP(cursor, id = self.id) |
| |
| |
| class NodeRev(SQLobject): |
| """O/R mapping for the noderev/string/nodeview table.""" |
| |
| _columns = ("id", "treeid", "nodeid", "origin", "parent", "branch", |
| "nameid", "name", "denameid", "dename", |
| "kind", "opcode", "state") |
| _put_statement = SQL.NODEREV_INSERT |
| _get_statement = SQL.NODEVIEW_GET |
| |
| # kind |
| DIR = "D" |
| FILE = "F" |
| |
| # opcode |
| ADD = "A" |
| REPLACE = "R" |
| MODIFY = "M" |
| DELETE = "D" |
| RENAME = "N" |
| BRANCH = "B" |
| LAZY = "L" |
| BREPLACE = "X" |
| LAZY_BREPLACE = "Z" |
| |
| # state |
| TRANSIENT = "T" |
| PERMANENT = "P" |
| |
| def __init__(self, **kwargs): |
| super(NodeRev, self).__init__(**kwargs) |
| if self.state is None: |
| self.state = self.TRANSIENT |
| |
| def __str__(self): |
| return "%d(%d) %c %s%s" % (self.id, self.treeid, self.opcode, |
| self.name, self._isdir and '/' or '') |
| |
| # Opcode names |
| __opnames = {ADD: "add", |
| REPLACE: "replace", |
| MODIFY: "modify", |
| DELETE: "delete", |
| RENAME: "rename", |
| BRANCH: "branch", |
| LAZY: "branch", |
| BREPLACE: "branch/replace", |
| LAZY_BREPLACE: "branch/replace"} |
| |
| @classmethod |
| def _opname(cls, change): |
| return cls.__opnames.get(opcode) |
| |
| @property |
| def _deleted(self): |
| return (self.opcode == self.DELETE) |
| |
| @property |
| def _lazy(self): |
| return (self.opcode in (self.LAZY, self.LAZY_BREPLACE)) |
| |
| @property |
| def _transient(self): |
| return (self.state == self.TRANSIENT) |
| |
| @property |
| def _isdir(self): |
| return (self.kind == self.DIR) |
| |
| @staticmethod |
| def __stringid(cursor, val): |
| SQL.STRING_FIND(cursor, val = val) |
| row = cursor.fetchone() |
| if row is not None: |
| return row['id'] |
| SQL.STRING_INSERT(cursor, val = val) |
| return cursor.lastrowid |
| |
| def _put(self, cursor): |
| if self.nameid is None: |
| assert self.name is not None |
| self.nameid = self.__stringid(cursor, self.name) |
| if self.denameid is None: |
| if self.dename == self.name: |
| self.denameid = self.nameid |
| else: |
| assert self.dename is not None |
| self.denameid = self.__stringid(cursor, self.dename) |
| super(NodeRev, self)._put(cursor) |
| if self.nodeid is None: |
| self.nodeid = self.id |
| if self.branch is None: |
| self.branch = self.id |
| |
| @classmethod |
| def _update_treeid(cls, cursor, new_txn, old_txn): |
| SQL.NODEREV_UPDATE_TREEID(cursor, |
| new_treeid = new_txn.treeid, |
| old_treeid = old_txn.treeid) |
| |
| def _delazify(self, cursor): |
| assert self._lazy and self._isdir |
| opcode = self.opcode == self.LAZY and self.BRANCH or self.BREPLACE |
| SQL.NODEREV_UPDATE_OPCODE(cursor, id = self.id, opcode = opcode) |
| self.opcode = opcode |
| |
| @classmethod |
| def _commit(cls, cursor, txn): |
| SQL.NODEREV_COMMIT(cursor, treeid = txn.treeid) |
| |
| @classmethod |
| def _cleanup(cls, cursor, txn): |
| SQL.NODEREV_CLEANUP(cursor, treeid = txn.treeid) |
| |
| @classmethod |
| def __find(cls, cursor, parent, name, txn): |
| if txn.state != txn.PERMANENT: |
| if parent is None: |
| finder = SQL.NODEVIEW_FIND_TRANSIENT_ROOT |
| else: |
| finder = SQL.NODEVIEW_FIND_TRANSIENT_BY_NAME |
| else: |
| if parent is None: |
| finder = SQL.NODEVIEW_FIND_ROOT |
| else: |
| finder = SQL.NODEVIEW_FIND_BY_NAME |
| finder(cursor, name = name, parent = parent, treeid = txn.treeid) |
| return cls._from_row(cursor.fetchone()) |
| |
| @classmethod |
| def _find(cls, cursor, parent, name, txn): |
| return cls.__find(cursor, parent, cls.__normtext(name), txn) |
| |
| @classmethod |
| def _commonprefix(cls, *args): |
| args = [arg.split('/') for arg in args] |
| prefix = [] |
| arglen = min(len(parts) for parts in args) |
| while arglen > 0: |
| same = set(cls.__normtext(parts[0]) for parts in args) |
| if len(same) > 1: |
| break |
| for parts in args: |
| del parts[0] |
| prefix.append(same.pop()) |
| arglen -= 1 |
| return '/'.join(prefix), ['/'.join(parts) for parts in args] |
| |
| @classmethod |
| def _lookup(cls, cursor, track, relpath, txn): |
| if track is None or track.path is None: |
| # Lookup from root |
| track = Track() |
| parent = cls.__find(cursor, None, "", txn) |
| if not relpath: |
| track.close(parent) |
| return track |
| track.append(parent) |
| else: |
| assert track.found |
| track = Track(track) |
| if not relpath: |
| track.close() |
| return track |
| parent = track.noderev |
| parts = cls.__normtext(relpath).split("/") |
| for name in parts[:-1]: |
| if not parent._isdir: |
| raise Error("ENOTDIR: " + track.path) |
| while parent._lazy: |
| parent = cls._get(cursor, id = parent.origin) |
| node = cls.__find(cursor, parent.branch, name, txn) |
| if node is None: |
| raise Error("ENODIR: " + track.path + '/' + name) |
| parent = node |
| track.append(parent) |
| while parent._lazy: |
| parent = cls._get(cursor, id = parent.origin) |
| track.close(cls.__find(cursor, parent.branch, parts[-1], txn)) |
| return track |
| |
| def _listdir(self, cursor, txn): |
| assert self._isdir |
| if txn.state != txn.PERMANENT: |
| lister = SQL.NODEVIEW_LIST_TRANSIENT_DIRECTORY |
| else: |
| lister = SQL.NODEVIEW_LIST_DIRECTORY |
| lister(cursor, parent = self.id, treeid = txn.treeid) |
| for row in cursor: |
| yield self._from_row(row) |
| |
| def _bubbledown(self, cursor, txn): |
| assert txn._uncommitted |
| assert self._lazy and self._isdir and self.origin is not None |
| originmap = dict() |
| origin = self |
| while origin._lazy: |
| origin = self._get(cursor, id = origin.origin) |
| for node in origin._listdir(cursor, txn): |
| newnode = node._branch(cursor, self, txn) |
| originmap[newnode.origin] == newnode |
| self._delazify(cursor) |
| return originmap |
| |
| def _branch(self, cursor, parent, txn, replaced=False): |
| assert txn._uncommitted |
| if self._isdir: |
| opcode = replaced and self.LAZY_BREPLACE or self.LAZY |
| else: |
| opcode = replaced and self.BREPLACE or self.BRANCH |
| node = self._revise(opcode, txn) |
| node.parent = parent.id |
| node.branch = None |
| node._put(cursor) |
| return node |
| |
| def _revise(self, opcode, txn): |
| assert txn._uncommitted |
| noderev = NodeRev._clone(self) |
| noderev.treeid = txn.treeid |
| noderev.origin = self.id |
| noderev.opcode = opcode |
| return noderev |
| |
| __readonly = frozenset(("name",)) |
| def __setitem__(self, key, value): |
| if key in self.__readonly: |
| raise Error("NodeRev.%s is read-only" % key) |
| if key == "dename": |
| name = self.__normtext(value) |
| value = self.__text(value) |
| if name != self.name: |
| super(NodeRev, self).__setitem__("name", name) |
| super(NodeRev, self).__setitem__("nameid", None) |
| super(NodeRev, self).__setitem__("denameid", None) |
| super(NodeRev, self).__setitem__(key, value) |
| |
| def __getitem__(self, key): |
| if key == "dename": |
| dename = super(NodeRev, self).__getitem__(key) |
| if dename is not None: |
| return dename |
| key = "name" |
| return super(NodeRev, self).__getitem__(key) |
| |
| @classmethod |
| def __text(cls, name): |
| if not isinstance(name, unicode): |
| return name.decode("UTF-8") |
| return name |
| |
| @classmethod |
| def __normtext(cls, name): |
| return unicodedata.normalize('NFC', cls.__text(name)) |
| |
| |
| class Track(object): |
| __slots__ = ("nodelist", "noderev", "lazy") |
| def __init__(self, other=None): |
| if other is None: |
| self.nodelist = list() |
| self.noderev = None |
| self.lazy = None |
| else: |
| self.nodelist = list(other.nodelist) |
| self.noderev = other.noderev |
| self.lazy = other.lazy |
| |
| def __str__(self): |
| return "%c%c %r" % ( |
| self.found and self.noderev.kind or '-', |
| self.lazy is not None and 'L' or '-', |
| self.path) |
| |
| @property |
| def found(self): |
| return (self.noderev is not None) |
| |
| @property |
| def parent(self): |
| if self.noderev is not None: |
| index = len(self.nodelist) - 2; |
| else: |
| index = len(self.nodelist) - 1; |
| if index >= 0: |
| return self.nodelist[index] |
| return None |
| |
| @property |
| def path(self): |
| if len(self.nodelist): |
| return '/'.join(n.name for n in self.nodelist[1:]) |
| return None |
| |
| @property |
| def open(self): |
| return not isinstance(self.nodelust, tuple) |
| |
| def append(self, noderev): |
| if self.lazy is None and noderev._lazy: |
| self.lazy = len(self.nodelist) |
| self.nodelist.append(noderev) |
| |
| def close(self, noderev=None): |
| if noderev is not None: |
| self.append(noderev) |
| self.noderev = noderev |
| self.nodelist = tuple(self.nodelist) |
| |
| def bubbledown(self, cursor, txn): |
| if self.lazy is None: |
| return |
| closed = not self.open |
| if closed: |
| self.nodelist = list(self.nodelist) |
| tracklen = len(self.nodelist) |
| index = self.lazy |
| node = self.nodelist[index] |
| originmap = node._bubbledown(cursor, txn) |
| while index < tracklen: |
| node = originmap[self.nodelist[index].id] |
| self.nodelist[index] = node |
| if node._isdir: |
| originmap = node._bubbledown(cursor, txn) |
| else: |
| originmap = None |
| index += 1 |
| self.lazy = None |
| if closed: |
| self.close() |
| |
| |
| class Index(object): |
| def __init__(self, database): |
| self.conn = sqlite3.connect(database, isolation_level = "DEFERRED") |
| self.conn.row_factory = sqlite3.Row |
| self.cursor = self.conn.cursor() |
| self.cursor.execute("PRAGMA page_size = 4096") |
| self.cursor.execute("PRAGMA temp_store = MEMORY") |
| self.cursor.execute("PRAGMA foreign_keys = ON") |
| self.cursor.execute("PRAGMA case_sensitive_like = ON") |
| self.cursor.execute("PRAGMA encoding = 'UTF-8'") |
| |
| def initialize(self): |
| try: |
| SQL.CREATE_SCHEMA(self.cursor) |
| SQL._execute( |
| self.cursor, |
| "UPDATE txn SET created = :created WHERE id = 0", |
| {"created": Txn._now()}) |
| self.commit() |
| except: |
| self.rollback() |
| raise |
| |
| def begin(self): |
| SQL._execute(self.cursor, "BEGIN") |
| |
| def commit(self): |
| SQL._log("COMMIT") |
| self.conn.commit() |
| |
| def rollback(self): |
| SQL._log("ROLLBACK") |
| self.conn.rollback() |
| |
| def close(self): |
| self.rollback() |
| SQL._log("CLOSE") |
| self.conn.close() |
| |
| def get_txn(self, revision=None): |
| if revision is None: |
| return Txn._find_newest(self.cursor) |
| return Txn._find_by_revision(self.cursor, revision) |
| |
| def new_txn(self, revision, created=None, author=None, base_txn = None): |
| assert base_txn is None or base_txn.revision == revision |
| txn = Txn(revision = revision, created = created, author = author, |
| treeid = base_txn is not None and base_txn.treeid or None) |
| txn._put(self.cursor) |
| return txn |
| |
| def commit_txn(self, txn, revision): |
| txn._commit(self.cursor, revision) |
| NodeRev._commit(self.cursor, txn) |
| |
| def abort_txn(self, txn): |
| txn._abort(self.cursor) |
| NodeRev._cleanup(self.cursor, txn) |
| txn._cleanup(self.cursor) |
| |
| def listdir(self, txn, noderev): |
| # FIXME: Query seems OK but no results returned? |
| return noderev._listdir(self.conn.cursor(), txn) |
| |
| def lookup(self, txn, track=None, relpath=""): |
| return NodeRev._lookup(self.cursor, track, relpath, txn) |
| |
| def __add(self, txn, track, name, kind, opcode, origintrack=None): |
| assert kind in (NodeRev.FILE, NodeRev.DIR) |
| assert opcode in (NodeRev.ADD, NodeRev.REPLACE) |
| if not txn._uncommitted: |
| raise Error("EREADONLY: txn " + str(txn)) |
| if not track.found: |
| raise Error("ENOENT: " + track.path) |
| if not track.noderev._isdir: |
| raise Error("ENOTDIR: " + track.path) |
| |
| parent = track.noderev |
| oldnode = NodeRev._find(self.cursor, parent.id, name, txn) |
| if opcode == NodeRev.ADD and oldnode is not None: |
| raise Error("EEXIST: " + track.path + '/' + name) |
| |
| if origintrack is not None: |
| # Treat add as copy |
| if not origintrack.found: |
| raise Error("ENOENT: (origin) " + origintrack.path) |
| origin = origintrack.noderev |
| if origin.kind != kind: |
| raise Error("ENOTSAME: origin %c -> copy %c" |
| % (origin.kind, kind)) |
| ### Rename detection heuristics here ... |
| rename = False |
| else: |
| origin = None |
| rename = False |
| |
| if rename: |
| raise NotImplementedError("Rename detection heuristics") |
| |
| track = Track(track) |
| track.bubbledown(self.cursor, txn) |
| if oldnode: |
| if parent.id != track.noderev.id: |
| # Bubbledown changed the track |
| parent = track.noderev |
| oldnode = NodeRev._find(self.cursor, parent.id, name, txn) |
| assert oldnode is not None |
| tombstone = oldnode._revise(oldnode.DELETE, txn) |
| tombstone.parent = parent.id |
| tombstone._put(self.cursor) |
| parent = track.noderev |
| if origin is not None: |
| newnode = origin._branch(self.cursor, parent.id, txn, |
| replaced = (oldnode is not None)) |
| else: |
| newnode = NodeRev(treeid = txn.treeid, |
| nodeid = None, |
| branch = None, |
| parent = parent.id, |
| kind = kind, |
| opcode = opcode) |
| newnode.dename = name |
| newnode._put(self.cursor) |
| track.close(newnode) |
| return track |
| |
| def add(self, txn, track, name, kind, origintrack=None): |
| return self.__add(txn, track, name, kind, NodeRev.ADD, origintrack) |
| |
| def replace(self, txn, track, name, kind, origintrack=None): |
| return self.__add(txn, track, name, kind, NodeRev.REPLACE, origintrack) |
| |
| # def modify(self, txn, track): |
| # if not txn._uncommitted |
| # raise Error("EREADONLY: txn " + str(txn)) |
| # if not track.found: |
| # raise Error("ENOENT: " + track.path) |
| |
| |
| |
| class Tree(object): |
| def __init__(self, index): |
| self.index = index |
| self.context = None |
| index.rollback() |
| |
| |
| __greek_tree = { |
| 'iota': 'file', |
| 'A': { |
| 'mu': 'file', |
| 'B': { |
| 'lambda': 'file', |
| 'E': { |
| 'alpha': 'file', |
| 'beta': 'file'}, |
| 'F': 'dir'}, |
| 'C': 'dir', |
| 'D': { |
| 'G': { |
| 'pi': 'file', |
| 'rho': 'file', |
| 'tau': 'file'}, |
| 'H': { |
| 'chi': 'file', |
| 'psi': 'file', |
| 'omega': 'file'} |
| } |
| } |
| } |
| def greektree(ix, tx): |
| def populate(track, items): |
| print('Populating', track) |
| for name, kind in items.iteritems(): |
| if kind == 'file': |
| node = ix.add(tx, track, name, NodeRev.FILE) |
| else: |
| node = ix.add(tx, track, name, NodeRev.DIR) |
| print('Added', node, 'node:', node.noderev) |
| if isinstance(kind, dict): |
| populate(node, kind) |
| |
| root = ix.lookup(tx) |
| populate(root, __greek_tree) |
| |
| |
| def simpletest(database): |
| ix = Index(database) |
| ix.initialize() |
| |
| try: |
| print("Lookup root") |
| tx = ix.get_txn() |
| print("transaction:", tx) |
| root = ix.lookup(tx) |
| print("root track:", root) |
| print("root noderev", root.noderev) |
| |
| print('Create greek tree') |
| tx = ix.new_txn(0) |
| print("transaction:", tx) |
| greektree(ix, tx) |
| ix.commit_txn(tx, 1) |
| ix.commit() |
| |
| |
| def listdir(noderev, prefix): |
| for n in ix.listdir(tx, noderev): |
| print(prefix, str(n)) |
| if n._isdir: |
| listdir(n, prefix + " ") |
| |
| print("List contents") |
| tx = ix.get_txn() |
| print("transaction:", tx) |
| root = ix.lookup(tx) |
| print(str(root.noderev)) |
| listdir(root.noderev, " ") |
| |
| print("Lookup iota") |
| track = ix.lookup(tx, None, "iota") |
| print(str(track), str(track.noderev)) |
| |
| print("Lookup A/D/H/psi") |
| track = ix.lookup(tx, None, "A/D/H/psi") |
| print(str(track), str(track.noderev)) |
| finally: |
| ix.close() |
| |
| def loggedsimpletest(database): |
| import sys |
| logging.basicConfig(level=SQL.LOGLEVEL, |
| stream=sys.stderr) |
| simpletest(database) |
