Exemplo n.º 1
0
    def testMoreFunctions(self):
        def test1(val):
            return val+1
        def test2(v1,v2):
            return v1+v2

        valid_replacements = (
            ('abs(',   'abs123(', {'abs123':test1}),
            ('round(', 'abs321(', {'abs321':test2}),
            ('',       '',        {'abs':test1}),
            ('',       '',        {'abs':test1, 'round':test2}),
            )

        create = self.complete_create
        for old_token, new_token, functions in valid_replacements:
            parse_view_spec( create.replace(old_token,new_token), functions )

        self.assertRaises(UnknownReferenceError,
                          parse_view_spec, create.replace('abs','abs1'),
                          {'abs2':test1})
Exemplo n.º 2
0
    def testLists(self):
        where = 'WHERE node.a5 in ($list)'
        where_statement = Template(TestStatements.t_view_def.safe_substitute(
            where=where, qos='', loops='', having=''))

        loop = 'FOREACH i IN ($list)'
        loop_statement = Template(TestStatements.t_view_def.safe_substitute(
            where='', qos='', loops=loop, having=''))

        valid_lists = [
            '1',
            '1:5',
            '"1"',
            '1,2,3,5,6,24',
            '1,2,3,5:6,24',
            '1.5,6.5,7.6',
            '"1", "2", "3","4"',
            'True, False, True, True, False',
            ]

        invalid_lists = [
            '1,'
            '1,"1"',
            '1,2,3,5.5:6,7',
            '1.2,5.5:6.1,7.2',
            '"1", "2", "3","4":"10"',
            '1, True',
            ]

        for statement in (where_statement, loop_statement):
            for list in valid_lists:
                parse_view_spec( statement.substitute(list=list) )
            for list in invalid_lists:
                self.assertRaises(ParseException,
                                  parse_view_spec,
                                  statement.substitute(list=list))
Exemplo n.º 3
0
    def testValidStatements(self):
        valid_replacements = (
            ('CREATE VIEW view', 'CREATE VIEW new_view2'),
            #('SELECT node', 'SELECT message, node'), # -> ParseError
            ('WHERE ', 'WHERE not '),
            (' == ', ' eq '),
            (' == ', ' <> '),
            (' < ', ' lt '),
            (' and ', ' and not '),
            (' or ', ' or not '),
            ('abs(', 'tan('),
            ('abs(', 'abs(var1+'),
            ('lowest(', 'highest('),
            ('lowest(', 'closest(3/4^2,'),
            ('"test"', '"test\'s"'),
            ('10 m', '95 d'),
            ('ON (node.a5)', 'ON (node.a5, node.a2)'),
            ('myconfval', 'myconfval=1*54'),
            ('old_view', 'old1, old2, old3'),
            )

        create = self.complete_create
        for old_token, new_token in valid_replacements:
            parse_view_spec(create.replace(old_token,new_token))
Exemplo n.º 4
0
    def testParseBuckets(self):
        statements = []
        for cr in self.create_buckets:
            try:
                statements.append(parse_view_spec(cr))
            except ParseException:
                print >>sys.stderr, cr
                raise

        self.assertEqual(True, statements[0].where_expression.evaluate())

        for i in range(1,len(statements)):
            self.assertEqual(1, len(statements[i].object_select))

            self.assertEqual(statements[0].view_object.name,
                             statements[i].view_object.name)
Exemplo n.º 5
0
    def testViewCreation(self):
        "Test: creating views"

        view_def = '''
        CREATE VIEW view_name
        AS SELECT node.a1 = node.a3 - node.a1,
                  node.a2 = node.a1 + node.a2,
                  node.a3 = 2 * node.a5 + node.a3,
                  node.a5,
                  node.a_new = 75
        RANKED lowest(2*5, node.a3*(node.a5^2)+1)
        FROM db
        '''

        where_clause = '''
        WHERE node.a3
           or (1+2*round(node.a1,2) = .1E5+4.E-4)
           or node.a1 == 1 and node.a2 == "test"
           or 1+node.a1 <> 4
        '''

        create       = view_def + ';'
        create_where = view_def + where_clause + ';'

        attr_names = [ 'a%s' % i for i in range(1,10) ]

        db = self.db
        for i in range(9):
            db.addAttribute(attr_names[i], int)

        for a5 in range(-100,100):
            node = DBNode(db)
            for i in range(9):
                setattr(node, attr_names[i], i+1)
            node.a5 = a5
            db.addNode(node)

        sview0 = NodeView( parse_view_spec(create.replace('view_name', 'sview0')), self.viewreg )
        self.assertEqual(2*5, len(sview0.getBucket()))

        sview1 = NodeView( parse_view_spec(create_where.replace('view_name', 'sview1')), self.viewreg )
        self.assertEqual(2*5, len(sview1.getBucket()))

        sview0_bucket = sview0.getBucket()
        for node in sview1.getBucket():
            self.assert_(node in sview0_bucket)

        create_subview = create_where.replace('FROM db', 'FROM sview0')
        sview2 = NodeView( parse_view_spec(create_subview.replace('view_name', 'sview2')), self.viewreg )
        self.assertEqual(2*5, len(sview2.getBucket()))

        create_mergeview = create_where.replace('2*5','2*10').replace('FROM db', 'FROM sview0, sview1')
        sview3 = NodeView( parse_view_spec(create_mergeview.replace('view_name', 'sview3')), self.viewreg )

        # both parent nodes are equal, merging them should filter duplicates
        self.assertEqual(2*5, len(sview3.getBucket()))

##         # merging parents without DISTINCT adds duplicates
##         create_mergeview_dup = create_mergeview.replace('DISTINCT','')
##         sview3_dup = NodeView( parse_view_spec(create_mergeview_dup.replace('view_name', 'sview3_dup')), self.viewreg )

##         self.assertEqual(2*10, len(sview3_dup.getBucket()))

        # verify that nodes only appear once
        nodes = []
        for node in sview3.getBucket():
            self.assert_(node not in nodes)
            nodes.append(node)

        # retry inheriting from all known views
        for i in range(10):
            list_of_known_views = ','.join(view_name for view_name in self.viewreg)
            create_mergeview = create_where.replace('2*5', '2*20').replace('FROM db', 'FROM '+list_of_known_views)
            sview4 = NodeView( parse_view_spec(create_mergeview.replace('view_name', 'sview%02d'%i)), self.viewreg )

        # verify that nodes only appear once
        nodes = []
        for node in sview3.getBucket():
            self.assert_(node not in nodes)
            nodes.append(node)

        nodes_a5 = set()
        for node in sview4.getBucket():
            self.assert_(node.a5 not in nodes_a5)
            nodes_a5.add(node.a5)
Exemplo n.º 6
0
    def testViewCircle(self):
        """Test: ring topology
        Each node has one or more neighbours in each direction.
        """

        node_count = self.NODE_COUNT

        db = self.db
        db.addAttribute('id', int)
        nodes = [ DBNode(db, id=n) for n in range(node_count) ]

        self.db.addNodes(nodes)

        circle_view_def = Template('''
        CREATE VIEW circle_neighbours_${id}_$cmp
        AS SELECT node.id
        RANKED lowest(ncount, dist($id, node.id))
        FROM db
        WITH ncount=1
        WHERE abs(node.id - $id) <= $maxid / 2  and     node.id $cmp $id
           or abs(node.id - $id) >  $maxid / 2  and not node.id $cmp $id
        ;
        ''')

        def ring_dist(n1, n2):
            return min(abs(n1 - n2), max_id - abs(n1 - n2))

        func_def = {'dist':ring_dist}
        max_id   = node_count

        viewreg = self.viewreg
        for node in nodes:
            view_spec_lt = circle_view_def.substitute(maxid=max_id, id=node.id, cmp='lt')
            view_spec_gt = circle_view_def.substitute(maxid=max_id, id=node.id, cmp='gt')

            spec_lt = parse_view_spec(view_spec_lt, func_def)
            spec_gt = parse_view_spec(view_spec_gt, func_def)

            node._lt = NodeView(spec_lt, viewreg)
            node._gt = NodeView(spec_gt, viewreg)

        for ncount in (1,4):
            for node in nodes:
                node._lt.setVariable('ncount', ncount)
                node._gt.setVariable('ncount', ncount)

            for node in nodes:
                self.assertEqual(ncount, len(node._lt.getBucket()))
                self.assertEqual(ncount, len(node._gt.getBucket()))

            # test if nodes know their neighbours
            node_count = len(nodes)
            neighbour_iterators = [ islice(niter, i, node_count+i)
                                    for (i, niter) in enumerate(tee(chain(nodes,nodes,nodes), ncount+1)) ]

            for neighbours in izip(*neighbour_iterators):
                node = neighbours[0]
                for neighbour in neighbours[1:]:
                    self.assert_(neighbour     in node._gt.getBucket())
                    self.assert_(neighbour not in node._lt.getBucket())
                    self.assert_(node      not in neighbour._gt.getBucket())
                    self.assert_(node          in neighbour._lt.getBucket())

            if DRAW_GRAPHS:
                ViewGraph.write_files( [ (node, (node._lt, node._gt))
                                         for node in nodes ],
                                       program='circo', fname='circle%02d'%ncount )

            if SHOW_VISUAL3D:
                VisualViewGraph( [ (node, (node._lt, node._gt))
                                   for node in nodes ],
                                 program='circo', graph_name='Circle%02d'%ncount )

            self.viewreg.unregister_all()
Exemplo n.º 7
0
    def testViewVariables(self):
        "Test: variable usage in views"

        view_def = '''
        CREATE VIEW view_name
        AS SELECT node.a1 = (node.a3 - node.a1) * var_a,
                  node.a2 = node.a1 + node.a2,
                  node.a3 = 2 * node.a5 + node.a3,
                  node.a5,
                  node.a_new = var_a
        RANKED lowest(var_a*2, var_a*node.a3*(node.a5^2)+1)
        FROM db
        WITH var_a = 5
        '''

        where_clause = '''
        WHERE node.a3
           or (1+2*round(node.a1,2) = .1E5+4.E-4)
           or node.a1 == 1 and node.a2 == "test"
           or 1+node.a1 <> 4
        '''

        create       = view_def + ';'
        create_where = view_def + where_clause + ';'

        attr_names = [ 'a%s' % i for i in range(1,10) ]

        db = self.db
        for i in range(9):
            db.addAttribute(attr_names[i], int)

        for a5 in range(-100,100):
            node = DBNode(db)
            for i in range(9):
                setattr(node, attr_names[i], i+1)
            node.a5 = a5
            db.addNode(node)


        sview0 = NodeView( parse_view_spec(create.replace('view_name', 'sview0')), self.viewreg )

        self.assertEqual(len(sview0.getBucket()), len(sview0))

        some_node = sview0.getBucket()[0]
        a1_of_some_node = some_node.a1

        self.assertEqual(2*5, len(sview0))
        sview0.setVariable('var_a', 8)
        self.assertEqual(2*8, len(sview0))

        some_node = sview0.getBucket()[0]
        self.assertNotEqual(a1_of_some_node, some_node.a1)

        sview1 = NodeView( parse_view_spec(create_where.replace('view_name', 'sview1')), self.viewreg )

        self.assertEqual(2* 5, len(sview1))
        sview1.setVariable('var_a', 16)
        self.assertEqual(2*16, len(sview1))
        self.assertEqual(2* 8, len(sview0))

        create_subview = create_where.replace('FROM db', 'FROM sview0')
        sview2 = NodeView( parse_view_spec(create_subview.replace('view_name', 'sview2')), self.viewreg )

        sview2.setVariable('var_a', 1000)
        self.assertEqual(2*8,  len(sview0))
        self.assertEqual(2*8,  len(sview2))
        self.assertEqual(2*16, len(sview1))