Revision 585b75e7 snf-pithos-backend/pithos/backends/lib/sqlalchemy/node.py

b/snf-pithos-backend/pithos/backends/lib/sqlalchemy/node.py
122 122 
                                         ondelete='CASCADE',
123 123 
                                         onupdate='CASCADE'),
124 124 
                              autoincrement=False))
125 
        columns.append(Column('latest_version', Integer))
125 126 
        columns.append(Column('path', String(2048), default='', nullable=False))
126 127 
        self.nodes = Table('nodes', metadata, *columns, mysql_engine='InnoDB')
127 128 
        Index('idx_nodes_path', self.nodes.c.path, unique=True)
129 
        Index('idx_nodes_parent', self.nodes.c.parent)
128 130
129 131 
        #create policy table
130 132 
        columns=[]
......
170 172 
        self.versions = Table('versions', metadata, *columns, mysql_engine='InnoDB')
171 173 
        Index('idx_versions_node_mtime', self.versions.c.node, self.versions.c.mtime)
172 174 
        Index('idx_versions_node_uuid', self.versions.c.uuid)
175 
        Index('idx_versions_serial_cluster', self.versions.c.serial, self.versions.c.cluster)
173 176
174 177 
        #create attributes table
175 178 
        columns = []
......
514 517 
                    self.versions.c.uuid,
515 518 
                    self.versions.c.checksum,
516 519 
                    self.versions.c.cluster])
517 
        filtered = select([func.max(self.versions.c.serial)],
518 
                            self.versions.c.node == node)
519 520 
        if before != inf:
521 
            filtered = select([func.max(self.versions.c.serial)],
522 
                            self.versions.c.node == node)
520 523 
            filtered = filtered.where(self.versions.c.mtime < before)
524 
        else:
525 
            filtered = select([self.nodes.c.latest_version],
526 
                            self.versions.c.node == node)
521 527 
        s = s.where(and_(self.versions.c.cluster != except_cluster,
522 528 
                         self.versions.c.serial == filtered))
523 529 
        r = self.conn.execute(s)
......
532 538 
        s = select([func.count(v.c.serial),
533 539 
                    func.sum(v.c.size),
534 540 
                    func.max(v.c.mtime)])
535 
        c1 = select([func.max(self.versions.c.serial)])
536 541 
        if before != inf:
542 
            c1 = select([func.max(self.versions.c.serial)])
537 543 
            c1 = c1.where(self.versions.c.mtime < before)
544 
            c1.where(self.versions.c.node == v.c.node)
545 
        else:
546 
            c1 = select([self.nodes.c.latest_version])
547 
            c1.where(self.nodes.c.node == v.c.node)
538 548 
        c2 = select([self.nodes.c.node], self.nodes.c.parent == node)
539 
        s = s.where(and_(v.c.serial == c1.where(self.versions.c.node == v.c.node),
549 
        s = s.where(and_(v.c.serial == c1,
540 550 
                         v.c.cluster != except_cluster,
541 551 
                         v.c.node.in_(c2)))
542 552 
        rp = self.conn.execute(s)
......
554 564 
        s = select([func.count(v.c.serial),
555 565 
                    func.sum(v.c.size),
556 566 
                    func.max(v.c.mtime)])
557 
        c1 = select([func.max(self.versions.c.serial)],
558 
            self.versions.c.node == v.c.node)
559 567 
        if before != inf:
568 
            c1 = select([func.max(self.versions.c.serial)],
569 
                    self.versions.c.node == v.c.node)
560 570 
            c1 = c1.where(self.versions.c.mtime < before)
571 
        else:
572 
            c1 = select([self.nodes.c.serial],
573 
                    self.nodes.c.node == v.c.node)
561 574 
        c2 = select([self.nodes.c.node], self.nodes.c.path.like(self.escape_like(path) + '%', escape='\\'))
562 575 
        s = s.where(and_(v.c.serial == c1,
563 576 
                         v.c.cluster != except_cluster,
......
571 584 
        mtime = max(mtime, r[2])
572 585 
        return (count, size, mtime)
573 586
587 
    def nodes_set_latest_version(self, node, serial):
588 
        s = self.nodes.update().where(self.nodes.c.node == node)
589 
        s = s.values(latest_version = serial)
590 
        self.conn.execute(s).close()
591
574 592 
    def version_create(self, node, hash, size, type, source, muser, uuid, checksum, cluster=0):
575 593 
        """Create a new version from the given properties.
576 594 
           Return the (serial, mtime) of the new version.
......
581 599 
                                          mtime=mtime, muser=muser, uuid=uuid, checksum=checksum, cluster=cluster)
582 600 
        serial = self.conn.execute(s).inserted_primary_key[0]
583 601 
        self.statistics_update_ancestors(node, 1, size, mtime, cluster)
602
603 
        self.nodes_set_latest_version(node, serial)
604
584 605 
        return serial, mtime
585 606
586 607 
    def version_lookup(self, node, before=inf, cluster=0, all_props=True):
......
598 619 
                        v.c.size, v.c.type, v.c.source,
599 620 
                        v.c.mtime, v.c.muser, v.c.uuid,
600 621 
                        v.c.checksum, v.c.cluster])
601 
        c = select([func.max(self.versions.c.serial)],
602 
            self.versions.c.node == node)
603 622 
        if before != inf:
623 
            c = select([func.max(self.versions.c.serial)],
624 
                self.versions.c.node == node)
604 625 
            c = c.where(self.versions.c.mtime < before)
626 
        else:
627 
            c = select([self.nodes.c.latest_version],
628 
                self.nodes.c.node == node)
605 629 
        s = s.where(and_(v.c.serial == c,
606 630 
                         v.c.cluster == cluster))
607 631 
        r = self.conn.execute(s)
......
616 640 
           Return a list with their properties:
617 641 
           (serial, node, hash, size, type, source, mtime, muser, uuid, checksum, cluster).
618 642 
        """
619
643 
        if not nodes:
644 
            return ()
620 645 
        v = self.versions.alias('v')
621 646 
        if not all_props:
622 647 
            s = select([v.c.serial])
......
625 650 
                        v.c.size, v.c.type, v.c.source,
626 651 
                        v.c.mtime, v.c.muser, v.c.uuid,
627 652 
                        v.c.checksum, v.c.cluster])
628 
        c = select([func.max(self.versions.c.serial)],
629 
            self.versions.c.node.in_(nodes)).group_by(self.versions.c.node)
630 653 
        if before != inf:
654 
            c = select([func.max(self.versions.c.serial)],
655 
                self.versions.c.node.in_(nodes))
631 656 
            c = c.where(self.versions.c.mtime < before)
657 
            c = c.group_by(self.versions.c.node)
658 
        else:
659 
            c = select([self.nodes.c.latest_version],
660 
                self.nodes.c.node.in_(nodes))
632 661 
        s = s.where(and_(v.c.serial.in_(c),
633 662 
                         v.c.cluster == cluster))
634 663 
        s = s.order_by(v.c.node)
......
706 735
707 736 
        s = self.versions.delete().where(self.versions.c.serial == serial)
708 737 
        self.conn.execute(s).close()
738
739 
        props = self.version_lookup(node, cluster=cluster, all_props=False)
740 
        if props:
741 
            self.nodes_set_latest_version(v.node, serial)
742
709 743 
        return hash, size
710 744
711 745 
    def attribute_get(self, serial, domain, keys=()):
......
799 833 
        v = self.versions.alias('v')
800 834 
        n = self.nodes.alias('n')
801 835 
        s = select([a.c.key]).distinct()
802 
        filtered = select([func.max(self.versions.c.serial)])
803 836 
        if before != inf:
837 
            filtered = select([func.max(self.versions.c.serial)])
804 838 
            filtered = filtered.where(self.versions.c.mtime < before)
805 
        s = s.where(v.c.serial == filtered.where(self.versions.c.node == v.c.node))
839 
            filtered = filtered.where(self.versions.c.node == v.c.node)
840 
        else:
841 
            filtered = select([self.nodes.c.latest_version])
842 
            filtered = filtered.where(self.nodes.c.node == v.c.node)
843 
        s = s.where(v.c.serial == filtered)
806 844 
        s = s.where(v.c.cluster != except_cluster)
807 845 
        s = s.where(v.c.node.in_(select([self.nodes.c.node],
808 846 
            self.nodes.c.parent == parent)))
......
890 928 
                        v.c.size, v.c.type, v.c.source,
891 929 
                        v.c.mtime, v.c.muser, v.c.uuid,
892 930 
                        v.c.checksum, v.c.cluster]).distinct()
893 
        filtered = select([func.max(self.versions.c.serial)])
894 931 
        if before != inf:
932 
            filtered = select([func.max(self.versions.c.serial)])
895 933 
            filtered = filtered.where(self.versions.c.mtime < before)
896 
        s = s.where(v.c.serial == filtered.where(self.versions.c.node == v.c.node))
934 
        else:
935 
            filtered = select([self.nodes.c.latest_version])
936 
        s = s.where(v.c.serial == filtered.where(self.nodes.c.node == v.c.node))
897 937 
        s = s.where(v.c.cluster != except_cluster)
898 938 
        s = s.where(v.c.node.in_(select([self.nodes.c.node],
899 939 
            self.nodes.c.parent == parent)))

Also available in: Unified diff