Synnefo » Pithos

    """return the first unicode string

    """return an approximation of the last unicode string

import re

_regexfilter = re.compile('(!?)\s*([\w-]+)\s*(=|!=|<=|>=|<|>)?\s*(.*)$', re.UNICODE)

    """Nodes store path organization.

       Versions store object history.

    # TODO: Keep size of object in one place.

        # execute(""" create index if not exists idx_versions_path

        #             on nodes(cluster, node, path) """)

        self.execute(q, (serial,))

        self.statistics_update(parent, -nr, -size, cluster)

        self.statistics_update_ancestors(parent, -nr, -size, cluster)

        self.statistics_update_ancestors(node, -nr, -size, cluster)

    def parse_filters(self, filterq):

        preterms = filterq.split(',')

        included = []

        excluded = []

        opers = []

        match = _regexfilter.match

        for term in preterms:

            m = match(term)

            if m is None:

                continue

            neg, key, op, value = m.groups()

            if neg:

                excluded.append(key)

            elif not value:

                included.append(key)

            elif op:

                opers.append((key, op, value))

        return included, excluded, opers

    def construct_filters(self, filterq):

        subqlist = []

        append = subqlist.append

        included, excluded, opers = self.parse_filters(filterq)

        args = []

        if included:

            subq = "key in ("

            subq += ','.join(('?' for x in included)) + ")"

            args += included

            append(subq)

        if excluded:

            subq = "key not in ("

            subq += ','.join(('?' for x in exluded)) + ")"

            args += excluded

            append(subq)

        if opers:

            t = (("(key = %s and value %s %s)" % (k, o, v)) for k, o, v in opers)

            subq = "(" + ' or '.join(t) + ")"

            args += opers

        if not subqlist:

            return None, None

        subq = " and serial in (select serial from attributes where "

        subq += ' and '.join(subqlist)

        subq += ")"

        return subq, args

#     def node_list(self, parent, prefix='',

#                    start='', delimiter=None,

#                    after=0.0, before=inf,

#                    filterq=None, versions=0,

#                    cluster=0, limit=10000):

#         """Return (a list of property tuples, a list of common prefixes)

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

#            matching the following criteria.

#            

#            The property tuple for a version is returned if all

#            of these conditions are true:

#            

#                 a. parent (and cluster) matches

#                 

#                 b. path > start

#                 

#                 c. path starts with prefix

#                 

#                 d. i  [versions=true]  version is in (after, before)

#                    ii [versions=false] version is the max in (after, before)

#                 

#                 e. the path does not have the delimiter occuring

#                    after the prefix.

#                 

#                 f. serial matches the attribute filter query.

#                    

#                    A filter query is a comma-separated list of

#                    terms in one of these three forms:

#                    

#                    key

#                        an attribute with this key must exist

#                    

#                    !key

#                        an attribute with this key must not exist

#                    

#                    key ?op value

#                        the attribute with this key satisfies the value

#                        where ?op is one of ==, != <=, >=, <, >.

#            

#            matching up to the first delimiter after prefix,

#            and are reported only once, as "virtual directories".

#            The delimiter is included in the prefixes.

#            Prefixes do appear from (e) even if no paths would match in (f).

#            

#            If arguments are None, then the corresponding matching rule

#            will always match.

#         """

#         

#         execute = self.execute

# 

#         if start < prefix:

#             start = strprevling(prefix)

# 

#         nextling = strnextling(prefix)

# 

#         q = ("select serial, parent, path, size, "

#                     "population, popsize, source, mtime, cluster "

#              "from nodes "

#              "where parent = ? and path > ? and path < ? "

#              "and mtime > ? and mtime < ? and cluster = ?")

#         args = [parent, start, nextling, after, before, cluster]

# 

#         if filterq:

#             subq, subargs = self.construct_filters(filterq)

#             if subq is not None:

#                 q += subq

#                 args += subargs

#         q += " order by path"

# 

#         if delimiter is None:

#             q += " limit ?"

#             args.append(limit)

#             execute(q, args)

#             return self.fetchall(), ()

# 

#         pfz = len(prefix)

#         dz = len(delimiter)

#         count = 0

#         fetchone = self.fetchone

#         prefixes = []

#         pappend = prefixes.append

#         matches = []

#         mappend = matches.append

#         

#         execute(q, args)

#         while 1:

#             props = fetchone()

#             if props is None:

#                 break

#             path = props[PATH]

#             idx = path.find(delimiter, pfz)

#             if idx < 0:

#                 mappend(props)

#                 count += 1

#                 if count >= limit:

#                     break

#                 continue

# 

#             pf = path[:idx + dz]

#             pappend(pf)

#             count += 1

#             ## XXX: if we break here due to limit,

#             ##      but a path would also be matched below,

#             ##      the path match would be lost since the

#             ##      next call with start=path would skip both of them.

#             ##      In this case, it is impossible to obey the limit,

#             ##      therefore we will break later, at limit + 1.

#             if idx + dz == len(path):

#                 mappend(props)

#                 count += 1

# 

#             if count >= limit: 

#                 break

# 

#             args[1] = strnextling(pf) # new start

#             execute(q, args)

# 

#         return matches, prefixes

    def latest_attribute_keys(self, parent, before=inf, except_cluster=0, allowed_paths=[]):

        q = ("select a.key "

        for path in allowed_paths:

            q += ' and n.path like ?'

            args += (path + '%',)

        """Create a block and return the hash."""

    def _check_policy(self, policy):

        for k in policy.keys():

            if policy[k] == '':

                policy[k] = self.default_policy.get(k)

        for k, v in policy.iteritems():

            if k == 'quota':

                q = int(v) # May raise ValueError.

                if q < 0:

                    raise ValueError

            elif k == 'versioning':

                if v not in ['auto', 'manual', 'none']:

                    raise ValueError

            else:

                raise ValueError

    def _sql_until(self, parent, until=None):

        """Return the sql to get the latest versions until the timestamp given."""

        if until is None:

            until = time.time()

        sql = ("select v.serial, n.path, v.mtime, v.size "

               "from versions v, nodes n "

               "where v.serial = (select max(serial) "

                                 "from versions "

                                 "where node = v.node and mtime < %s) "

               "and v.cluster != %s "

               "and v.node = n.node "

               "and v.node in (select node "

                              "from nodes "

                              "where parent = %s)")

        return sql % (until, CLUSTER_DELETED, parent)

    def _list_limits(self, listing, marker, limit):

        start = 0

        if marker:

            try:

                start = listing.index(marker) + 1

            except ValueError:

                pass

        if not limit or limit > 10000:

            limit = 10000

        return start, limit

    def _list_objects(self, parent, path, prefix='', delimiter=None, marker=None, limit=10000, virtual=True, keys=[], until=None, allowed=[]):

        cont_prefix = path + '/'

        if keys and len(keys) > 0:

#             sql = '''select distinct o.name, o.version_id from (%s) o, metadata m where o.name like ? and

#                         m.version_id = o.version_id and m.key in (%s)'''

#             sql = sql % (self._sql_until(until), ', '.join('?' * len(keys)))

#             param = (cont_prefix + prefix + '%',) + tuple(keys)

#             if allowed:

#                 sql += ' and (' + ' or '.join(('o.name like ?',) * len(allowed)) + ')'

#                 param += tuple([x + '%' for x in allowed])

#             sql += ' order by o.name'

            return []

        else:

            sql = 'select path, serial from (%s) where path like ?'

            sql = sql % self._sql_until(parent, until)

            param = (cont_prefix + prefix + '%',)

            if allowed:

                sql += ' and (' + ' or '.join(('name like ?',) * len(allowed)) + ')'

                param += tuple([x + '%' for x in allowed])

            sql += ' order by path'

        c = self.con.execute(sql, param)

        objects = [(x[0][len(cont_prefix):], x[1]) for x in c.fetchall()]

        if delimiter:

            pseudo_objects = []

            for x in objects:

                pseudo_name = x[0]

                i = pseudo_name.find(delimiter, len(prefix))

                if not virtual:

                    # If the delimiter is not found, or the name ends

                    # with the delimiter's first occurence.

                    if i == -1 or len(pseudo_name) == i + len(delimiter):

                        pseudo_objects.append(x)

                else:

                    # If the delimiter is found, keep up to (and including) the delimiter.

                    if i != -1:

                        pseudo_name = pseudo_name[:i + len(delimiter)]

                    if pseudo_name not in [y[0] for y in pseudo_objects]:

                        if pseudo_name == x[0]:

                            pseudo_objects.append(x)

                        else:

                            pseudo_objects.append((pseudo_name, None))

            objects = pseudo_objects

        start, limit = self._list_limits([x[0] for x in objects], marker, limit)

        return objects[start:start + limit]