Synnefo

from pithos.lib.filter import parse_filters

ROOTNODE  = 0

( SERIAL, NODE, HASH, SIZE, SOURCE, MTIME, MUSER, CLUSTER ) = range(8)

                                         ondelete='CASCADE',

                                         onupdate='CASCADE'),

                              primary_key=True))

        columns.append(Column('key', String(255), primary_key=True))

        columns.append(Column('value', String(255)))

        self.attributes = Table('attributes', metadata, *columns, mysql_engine='InnoDB')

        self.conn.execute(s).close()

        return hash

        """Return a list of (key, value) pairs of the version specified by serial.

           If keys is empty, return all attributes.

           Othwerise, return only those specified.

            attrs = self.attributes.alias()

            s = select([attrs.c.key, attrs.c.value])

            s = s.where(and_(attrs.c.key.in_(keys),

        else:

            attrs = self.attributes.alias()

            s = select([attrs.c.key, attrs.c.value])

        r = self.conn.execute(s)

        l = r.fetchall()

        r.close()

        return l

        """Set the attributes of the version specified by serial.

           Receive attributes as an iterable of (key, value) pairs.

        """

        for k, v in items:

            s = self.attributes.update()

            s = s.where(and_(self.attributes.c.serial == serial,

                             self.attributes.c.key == k))

            s = s.values(value = v)

            rp = self.conn.execute(s)

            rp.close()

            if rp.rowcount == 0:

                s = self.attributes.insert()

                self.conn.execute(s).close()

        """Delete attributes of the version specified by serial.

           If keys is empty, delete all attributes.

           Otherwise delete those specified.

            for key in keys:

                s = self.attributes.delete()

                s = s.where(and_(self.attributes.c.serial == serial,

                                 self.attributes.c.key == key))

                self.conn.execute(s).close()

        else:

            s = self.attributes.delete()

            self.conn.execute(s).close()

    def attribute_copy(self, source, dest):

            self.attributes.c.serial == source)

        rp = self.conn.execute(s)

        attributes = rp.fetchall()

        rp.close()

            #insert or replace

            s = self.attributes.update().where(and_(

                self.attributes.c.serial == dest,

                self.attributes.c.key == k))

            rp = self.conn.execute(s, value=v)

            rp.close()

            if rp.rowcount == 0:

                s = self.attributes.insert()

                self.conn.execute(s, values).close()

        """Return a list with all keys pairs defined

           for all latest versions under parent that

           do not belong to the cluster.

        s = s.where(v.c.node.in_(select([self.nodes.c.node],

            self.nodes.c.parent == parent)))

        s = s.where(a.c.serial == v.c.serial)

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

        conj = []

        for x in pathq:

    def latest_version_list(self, parent, prefix='', delimiter=None,

                            start='', limit=10000, before=inf,

        """Return a (list of (path, serial) tuples, list of common prefixes)

           for the current versions of the paths with the given parent,

           matching the following criteria.

        s = s.where(v.c.cluster != except_cluster)

        s = s.where(v.c.node.in_(select([self.nodes.c.node],

            self.nodes.c.parent == parent)))

            s = s.where(a.c.serial == v.c.serial)

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

        s = s.where(and_(n.c.path > bindparam('start'), n.c.path < nextling))

        if conj:

            s = s.where(or_(*conj))

            included, excluded, opers = parse_filters(filterq)

            if included:

                s = s.where(a.c.key.in_(x for x in included))