Synnefo

ROOTNODE = 0

(SERIAL, NODE, HASH, SIZE, TYPE, SOURCE, MTIME, MUSER, UUID, CHECKSUM,

(MATCH_PREFIX, MATCH_EXACT) = range(2)

    'uuid': 8,

    'checksum': 9,

    'cluster': 10,

}

    columns.append(Column('uuid', String(64), nullable=False, default=''))

    columns.append(Column('checksum', String(256), nullable=False, default=''))

    columns.append(Column('cluster', Integer, nullable=False, default=0))

    versions = Table('versions', metadata, *columns, mysql_engine='InnoDB')

    Index('idx_versions_node_mtime', versions.c.node, versions.c.mtime)

    Index('idx_versions_node_uuid', versions.c.uuid)

        """Return the properties of all versions at node.

           If keys is empty, return all properties in the order

           (serial, node, hash, size, type, source, mtime, muser, uuid,

        """

        s = select([self.versions.c.serial,

                    self.versions.c.muser,

                    self.versions.c.uuid,

                    self.versions.c.checksum,

        s = s.order_by(self.versions.c.serial)

        r = self.conn.execute(s)

        rows = r.fetchall()

    def version_create(self, node, hash, size, type, source, muser, uuid,

                       checksum, cluster=0,

        """Create a new version from the given properties.

           Return the (serial, mtime) of the new version.

        """

        s = self.versions.insert().values(

            node=node, hash=hash, size=size, type=type, source=source,

            mtime=mtime, muser=muser, uuid=uuid, checksum=checksum,

        serial = self.conn.execute(s).inserted_primary_key[0]

        self.statistics_update_ancestors(node, 1, size, mtime, cluster,

                                         update_statistics_ancestors_depth)

        """Lookup the current version of the given node.

           Return a list with its properties:

           (serial, node, hash, size, type, source, mtime,

           or None if the current version is not found in the given cluster.

        """

            s = select([v.c.serial, v.c.node, v.c.hash,

                        v.c.size, v.c.type, v.c.source,

                        v.c.mtime, v.c.muser, v.c.uuid,

        if before != inf:

            c = select([func.max(self.versions.c.serial)],

                       self.versions.c.node == node)

        """Lookup the current versions of the given nodes.

           Return a list with their properties:

           (serial, node, hash, size, type, source, mtime, muser, uuid,

        """

        if not nodes:

            return ()

            s = select([v.c.serial, v.c.node, v.c.hash,

                        v.c.size, v.c.type, v.c.source,

                        v.c.mtime, v.c.muser, v.c.uuid,

        if before != inf:

            c = select([func.max(self.versions.c.serial)],

                       self.versions.c.node.in_(nodes))

           the version specified by serial and the keys, in the order given.

           If keys is empty, return all properties in the order

           (serial, node, hash, size, type, source, mtime, muser, uuid,

        """

        v = self.versions.alias()

        s = select([v.c.serial, v.c.node, v.c.hash,

                    v.c.size, v.c.type, v.c.source,

                    v.c.mtime, v.c.muser, v.c.uuid,

        if node is not None:

            s = s.where(v.c.node == node)

        rp = self.conn.execute(s)