Пример #1
0
    def testFieldFormatters(self):  # Formatter should be called Validator

        # Test the default formatters
        for typ in ALLOWED_DATATYPES:
            f = Field("abc", typ)
            if typ not in ["date", "time", "datetime"]:
                isinstance(f.formatter("test"), str)
            else:
                isinstance(f.formatter(datetime.datetime.now()), str)
Пример #2
0
    def testFieldFormatters(self):  # Formatter should be called Validator

        # Test the default formatters
        for typ in ALLOWED_DATATYPES:
            f = Field('abc', typ)
            if typ not in ['date', 'time', 'datetime']:
                isinstance(f.formatter('test'), str)
            else:
                isinstance(f.formatter(datetime.datetime.now()), str)
Пример #3
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('t1', Field('aa'))
     db.define_table('t2', Field('aa'), Field('b', db.t1))
     i1 = db.t1.insert(aa='1')
     i2 = db.t1.insert(aa='2')
     i3 = db.t1.insert(aa='3')
     db.t2.insert(aa='4', b=i1)
     db.t2.insert(aa='5', b=i2)
     db.t2.insert(aa='6', b=i2)
     db.t1._common_filter = lambda q: db.t1.aa>1
     self.assertEqual(db(db.t1).count(),2)
     self.assertEqual(db(db.t1).count(),2)
     q = db.t2.b==db.t1.id
     self.assertEqual(db(q).count(),2)
     self.assertEqual(db(q).count(),2)        
     self.assertEqual(len(db(db.t1).select(left=db.t2.on(q))),3)
     db.t2._common_filter = lambda q: db.t2.aa<6
     self.assertEqual(db(q).count(),1)
     self.assertEqual(db(q).count(),1)
     self.assertEqual(len(db(db.t1).select(left=db.t2.on(q))),2)
     db.t2.drop()
     db.t1.drop()
Пример #4
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'))
     self.assertEqual(db.tt.insert(aa='1'), 1)
     self.assertEqual(db.tt.insert(aa='1'), 2)
     self.assertEqual(db.tt.insert(aa='1'), 3)
     self.assertEqual(db(db.tt.aa == '1').count(), 3)
     self.assertEqual(db(db.tt.aa == '2').isempty(), True)
     self.assertEqual(db(db.tt.aa == '1').update(aa='2'), 3)
     self.assertEqual(db(db.tt.aa == '2').count(), 3)
     self.assertEqual(db(db.tt.aa == '2').isempty(), False)
     self.assertEqual(db(db.tt.aa == '2').delete(), 3)
     self.assertEqual(db(db.tt.aa == '2').isempty(), True)
     db.tt.drop()
Пример #5
0
    def testRun(self):
        db = DAL(DEFAULT_URI, check_reserved=['all'])
        db.define_table('tt', Field('aa'))
        db.commit()
        db.tt.insert(aa="test")

        class Compute:
            def a_upper(row):
                return row.tt.aa.upper()

        db.tt.virtualfields.append(Compute())
        assert db(db.tt.id > 0).select().first().a_upper == 'TEST'
        db.tt.drop()
        db.commit()
Пример #6
0
    def testRun(self):
        db = DAL('sqlite:memory:')
        db.define_table('t', Field('a'))
        db.commit()
        db.t.insert(a="test")

        class Compute:
            def a_upper(row):
                return row.t.a.upper()

        db.t.virtualfields.append(Compute())
        assert db(db.t.id > 0).select().first().a_upper == 'TEST'
        db.t.drop()
        db.commit()
Пример #7
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a'))
     self.assertEqual(db.t.insert(a='abc'), 1)
     self.assertEqual(len(db(db.t.a.like('a%')).select()), 1)
     self.assertEqual(len(db(db.t.a.like('%b%')).select()), 1)
     self.assertEqual(len(db(db.t.a.like('%c')).select()), 1)
     self.assertEqual(len(db(db.t.a.like('%d%')).select()), 0)
     self.assertEqual(len(db(db.t.a.lower().like('A%')).select()), 1)
     self.assertEqual(len(db(db.t.a.lower().like('%B%')).select()), 1)
     self.assertEqual(len(db(db.t.a.lower().like('%C')).select()), 1)
     self.assertEqual(len(db(db.t.a.upper().like('A%')).select()), 1)
     self.assertEqual(len(db(db.t.a.upper().like('%B%')).select()), 1)
     self.assertEqual(len(db(db.t.a.upper().like('%C')).select()), 1)
     db.t.drop()
Пример #8
0
    def testFieldName(self):

        # Check that Fields cannot start with underscores
        self.assertRaises(SyntaxError, Field, '_abc', 'string')

        # Check that Fields cannot contain punctuation other than underscores
        self.assertRaises(SyntaxError, Field, 'a.bc', 'string')

        # Check that Fields cannot be a name of a method or property of Table
        for x in ['drop', 'on', 'truncate']:
            self.assertRaises(SyntaxError, Field, x, 'string')

        # Check that Fields allows underscores in the body of a field name.
        self.assert_(Field('a_bc', 'string'),
            "Field isn't allowing underscores in fieldnames.  It should.")
Пример #9
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a', 'integer'))
     self.assertEqual(db.t.insert(a=1), 1)
     self.assertEqual(db.t.insert(a=2), 2)
     self.assertEqual(db.t.insert(a=3), 3)
     s = db.t.a.min()
     self.assertEqual(db(db.t.id > 0).select(s)[0]._extra[s], 1)
     s = db.t.a.max()
     self.assertEqual(db(db.t.id > 0).select(s)[0]._extra[s], 3)
     s = db.t.a.sum()
     self.assertEqual(db(db.t.id > 0).select(s)[0]._extra[s], 6)
     s = db.t.a.count()
     self.assertEqual(db(db.t.id > 0).select(s)[0]._extra[s], 3)
     db.t.drop()
Пример #10
0
 def testRun(self):
     from cache import CacheInRam
     cache = CacheInRam()
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a'))
     db.t.insert(a='1')
     r0 = db().select(db.t.ALL)
     r1 = db().select(db.t.ALL, cache=(cache, 1000))
     self.assertEqual(len(r0), len(r1))
     r2 = db().select(db.t.ALL, cache=(cache, 1000))
     self.assertEqual(len(r0), len(r2))
     r3 = db().select(db.t.ALL, cache=(cache, 1000), cacheable=True)
     self.assertEqual(len(r0), len(r3))
     r4 = db().select(db.t.ALL, cache=(cache, 1000), cacheable=True)
     self.assertEqual(len(r0), len(r4))
     db.t.drop()
Пример #11
0
 def testRun(self):
     from cache import CacheInRam
     cache = CacheInRam()
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'))
     db.tt.insert(aa='1')
     r0 = db().select(db.tt.ALL)
     r1 = db().select(db.tt.ALL, cache=(cache, 1000))
     self.assertEqual(len(r0), len(r1))
     r2 = db().select(db.tt.ALL, cache=(cache, 1000))
     self.assertEqual(len(r0), len(r2))
     r3 = db().select(db.tt.ALL, cache=(cache, 1000), cacheable=True)
     self.assertEqual(len(r0), len(r3))
     r4 = db().select(db.tt.ALL, cache=(cache, 1000), cacheable=True)
     self.assertEqual(len(r0), len(r4))
     db.tt.drop()
Пример #12
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a'))
     self.assertEqual(db.t.insert(a='1'), 1)
     self.assertEqual(db.t.insert(a='2'), 2)
     self.assertEqual(db.t.insert(a='3'), 3)
     self.assertEqual(len(db(db.t.a.belongs(('1', '3'))).select()),
                      2)
     self.assertEqual(len(db(db.t.a.belongs(db(db.t.id
                       > 2)._select(db.t.a))).select()), 1)
     self.assertEqual(len(db(db.t.a.belongs(db(db.t.a.belongs(('1',
                      '3')))._select(db.t.a))).select()), 2)
     self.assertEqual(len(db(db.t.a.belongs(db(db.t.a.belongs(db
                      (db.t.a.belongs(('1', '3')))._select(db.t.a)))._select(
                      db.t.a))).select()),
                      2)
     db.t.drop()
Пример #13
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'))
     self.assertEqual(db.tt.insert(aa='1'), 1)
     self.assertEqual(db.tt.insert(aa='2'), 2)
     self.assertEqual(db.tt.insert(aa='3'), 3)
     self.assertEqual(db(db.tt.aa.belongs(('1', '3'))).count(),
                      2)
     self.assertEqual(db(db.tt.aa.belongs(db(db.tt.id
                       > 2)._select(db.tt.aa))).count(), 1)
     self.assertEqual(db(db.tt.aa.belongs(db(db.tt.aa.belongs(('1',
                      '3')))._select(db.tt.aa))).count(), 2)
     self.assertEqual(db(db.tt.aa.belongs(db(db.tt.aa.belongs(db
                      (db.tt.aa.belongs(('1', '3')))._select(db.tt.aa)))._select(
                      db.tt.aa))).count(),
                      2)
     db.tt.drop()
Пример #14
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a', 'datetime'))
     self.assertEqual(db.t.insert(a=datetime.datetime(1971, 12, 21,
                      11, 30)), 1)
     self.assertEqual(db.t.insert(a=datetime.datetime(1971, 11, 21,
                      10, 30)), 2)
     self.assertEqual(db.t.insert(a=datetime.datetime(1970, 12, 21,
                      9, 30)), 3)
     self.assertEqual(len(db(db.t.a == datetime.datetime(1971, 12,
                      21, 11, 30)).select()), 1)
     self.assertEqual(len(db(db.t.a.year() == 1971).select()), 2)
     self.assertEqual(len(db(db.t.a.month() == 12).select()), 2)
     self.assertEqual(len(db(db.t.a.day() == 21).select()), 3)
     self.assertEqual(len(db(db.t.a.hour() == 11).select()), 1)
     self.assertEqual(len(db(db.t.a.minutes() == 30).select()), 3)
     self.assertEqual(len(db(db.t.a.seconds() == 0).select()), 3)
     db.t.drop()
Пример #15
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa', 'datetime'))
     self.assertEqual(
         db.tt.insert(aa=datetime.datetime(1971, 12, 21, 11, 30)), 1)
     self.assertEqual(
         db.tt.insert(aa=datetime.datetime(1971, 11, 21, 10, 30)), 2)
     self.assertEqual(
         db.tt.insert(aa=datetime.datetime(1970, 12, 21, 9, 30)), 3)
     self.assertEqual(
         db(db.tt.aa == datetime.datetime(1971, 12, 21, 11, 30)).count(), 1)
     self.assertEqual(db(db.tt.aa.year() == 1971).count(), 2)
     self.assertEqual(db(db.tt.aa.month() == 12).count(), 2)
     self.assertEqual(db(db.tt.aa.day() == 21).count(), 3)
     self.assertEqual(db(db.tt.aa.hour() == 11).count(), 1)
     self.assertEqual(db(db.tt.aa.minutes() == 30).count(), 3)
     self.assertEqual(db(db.tt.aa.seconds() == 0).count(), 3)
     self.assertEqual(db(db.tt.aa.epoch() < 365 * 24 * 3600).count(), 1)
     db.tt.drop()
Пример #16
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa', 'integer'))
     self.assertEqual(db.tt.insert(aa=1), 1)
     self.assertEqual(db.tt.insert(aa=2), 2)
     self.assertEqual(db.tt.insert(aa=3), 3)
     s = db.tt.aa.min()
     self.assertEqual(db(db.tt.id > 0).select(s)[0]._extra[s], 1)
     self.assertEqual(db(db.tt.id > 0).select(s).first()[s], 1)
     self.assertEqual(db().select(s).first()[s], 1)
     s = db.tt.aa.max()
     self.assertEqual(db().select(s).first()[s], 3)
     s = db.tt.aa.sum()
     self.assertEqual(db().select(s).first()[s], 6)
     s = db.tt.aa.count()
     self.assertEqual(db().select(s).first()[s], 3)
     s = db.tt.aa.avg()
     self.assertEqual(db().select(s).first()[s], 2)
     db.tt.drop()
Пример #17
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t', Field('a'))
     db.commit()
     db.t.insert(a="test")
     rows1 = db(db.t.id>0).select()
     rows2 = db(db.t.id>0).select()
     rows3 = rows1 & rows2
     assert len(rows3) == 2
     rows4 = rows1 | rows2
     assert len(rows4) == 1
     rows5 = rows1.find(lambda row: row.a=="test")
     assert len(rows5) == 1
     rows6 = rows2.exclude(lambda row: row.a=="test")
     assert len(rows6) == 1
     rows7 = rows5.sort(lambda row: row.a)
     assert len(rows7) == 1
     db.t.drop()
     db.commit()
Пример #18
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'))
     db.commit()
     db.tt.insert(aa="test")
     rows1 = db(db.tt.id > 0).select()
     rows2 = db(db.tt.id > 0).select()
     rows3 = rows1 & rows2
     assert len(rows3) == 2
     rows4 = rows1 | rows2
     assert len(rows4) == 1
     rows5 = rows1.find(lambda row: row.aa == "test")
     assert len(rows5) == 1
     rows6 = rows2.exclude(lambda row: row.aa == "test")
     assert len(rows6) == 1
     rows7 = rows5.sort(lambda row: row.aa)
     assert len(rows7) == 1
     db.tt.drop()
     db.commit()
Пример #19
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     for ft in ['string', 'text', 'password', 'upload', 'blob']:
         db.define_table('t', Field('a', ft, default=''))
         self.assertEqual(db.t.insert(a='x'), 1)
         self.assertEqual(db().select(db.t.a)[0].a, 'x')
         db.t.drop()
     db.define_table('t', Field('a', 'integer', default=1))
     self.assertEqual(db.t.insert(a=3), 1)
     self.assertEqual(db().select(db.t.a)[0].a, 3)
     db.t.drop()
     db.define_table('t', Field('a', 'double', default=1))
     self.assertEqual(db.t.insert(a=3.1), 1)
     self.assertEqual(db().select(db.t.a)[0].a, 3.1)
     db.t.drop()
     db.define_table('t', Field('a', 'boolean', default=True))
     self.assertEqual(db.t.insert(a=True), 1)
     self.assertEqual(db().select(db.t.a)[0].a, True)
     db.t.drop()
     db.define_table('t', Field('a', 'date',
                     default=datetime.date.today()))
     t0 = datetime.date.today()
     self.assertEqual(db.t.insert(a=t0), 1)
     self.assertEqual(db().select(db.t.a)[0].a, t0)
     db.t.drop()
     db.define_table('t', Field('a', 'datetime',
                     default=datetime.datetime.today()))
     t0 = datetime.datetime(
         1971,
         12,
         21,
         10,
         30,
         55,
         0,
         )
     self.assertEqual(db.t.insert(a=t0), 1)
     self.assertEqual(db().select(db.t.a)[0].a, t0)
     db.t.drop()
     db.define_table('t', Field('a', 'time', default='11:30'))
     t0 = datetime.time(10, 30, 55)
     self.assertEqual(db.t.insert(a=t0), 1)
     self.assertEqual(db().select(db.t.a)[0].a, t0)
     db.t.drop()
Пример #20
0
    def testRun(self):
        db = DAL(DEFAULT_URI, check_reserved=['all'])
        db.define_table('tt', Field('aa'), Field('bb', default='x'),
                        Field('cc', compute=lambda r: r.aa + r.bb))
        db.commit()
        id = db.tt.insert(aa="z")
        self.assertEqual(db.tt[id].cc, 'zx')
        db.tt.drop()
        db.commit()

        # test checking that a compute field can refer to earlier-defined computed fields
        db.define_table('tt', Field('aa'), Field('bb', default='x'),
                        Field('cc', compute=lambda r: r.aa + r.bb),
                        Field('dd', compute=lambda r: r.bb + r.cc))
        db.commit()
        id = db.tt.insert(aa="z")
        self.assertEqual(db.tt[id].dd, 'xzx')
        db.tt.drop()
        db.commit()
Пример #21
0
 def testRun(self):
     db = DAL('sqlite://.storage.db')
     db.define_table('t', Field('a'), migrate='.storage.table')
     db.commit()
     db = DAL('sqlite://.storage.db')
     db.define_table('t', Field('a'), Field('b'),
                     migrate='.storage.table')
     db.commit()
     db = DAL('sqlite://.storage.db')
     db.define_table('t', Field('a'), Field('b', 'text'),
                     migrate='.storage.table')
     db.commit()
     db = DAL('sqlite://.storage.db')
     db.define_table('t', Field('a'), migrate='.storage.table')
     db.t.drop()
     db.commit()
Пример #22
0
 def testRun(self):
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'), migrate='.storage.table')
     db.commit()
     db.close()
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'), Field('b'),
                     migrate='.storage.table')
     db.commit()
     db.close()
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'), Field('b', 'text'),
                     migrate='.storage.table')
     db.commit()
     db.close()
     db = DAL(DEFAULT_URI, check_reserved=['all'])
     db.define_table('tt', Field('aa'), migrate='.storage.table')
     db.tt.drop()
     db.commit()
     db.close()
Пример #23
0
def lback_db():
    db = DAL('sqlite://db.sql', folder='/usr/local/lback/')
    db.define_table("backups",
                    Field('id'),
                    Field('uid'),
                    Field('name'),
                    Field('time'),
                    Field('folder'),
                    Field('size'),
                    Field('version'),
                    Field('jit'),
                    Field('local'),
                    migrate=True)
    db.define_table("restores",
                    Field("id"),
                    Field("uid"),
                    Field("backupId"),
                    Field("time"),
                    migrate=True)

    db.define_table("users",
                    Field('id'),
                    Field('username'),
                    Field('password'),
                    migrate=True)

    return db
Пример #24
0
    def testRun(self):
        db = DAL(DEFAULT_URI, check_reserved=['all'])
        db.define_table('person', Field('name', default="Michael"),
                        Field('uuid'))
        db.define_table('pet', Field('friend', db.person), Field('name'))
        dbdict = db.as_dict(flat=True, sanitize=False)
        assert isinstance(dbdict, dict)
        uri = dbdict["uri"]
        assert isinstance(uri, basestring) and uri
        assert len(dbdict["items"]) == 2
        assert len(dbdict["items"]["person"]["items"]) == 3
        assert dbdict["items"]["person"]["items"]["name"][
            "type"] == db.person.name.type
        assert dbdict["items"]["person"]["items"]["name"][
            "default"] == db.person.name.default
        assert dbdict

        db2 = DAL(dbdict, check_reserved=['all'])
        assert len(db.tables) == len(db2.tables)
        assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
        assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
        db.pet.drop()
        db.commit()

        db2.commit()

        have_serializers = True
        try:
            import serializers
            dbjson = db.as_json(sanitize=False)
            assert isinstance(dbjson, basestring) and len(dbjson) > 0

            unicode_keys = True
            if sys.version < "2.6.5":
                unicode_keys = False
            db3 = DAL(serializers.loads_json(dbjson,
                                             unicode_keys=unicode_keys))
            assert hasattr(db3, "person") and hasattr(db3.person, "uuid") and\
            db3.person.uuid.type == db.person.uuid.type
            db3.person.drop()
            db3.commit()
        except ImportError:
            pass

        mpfc = "Monty Python's Flying Circus"
        dbdict4 = {
            "uri": DEFAULT_URI,
            "items": {
                "staff": {
                    "items": {
                        "name": {
                            "default": "Michael"
                        },
                        "food": {
                            "default": "Spam"
                        },
                        "tvshow": {
                            "type": "reference tvshow"
                        }
                    }
                },
                "tvshow": {
                    "items": {
                        "name": {
                            "default": mpfc
                        },
                        "rating": {
                            "type": "double"
                        }
                    }
                }
            }
        }
        db4 = DAL(dbdict4, check_reserved=['all'])
        assert "staff" in db4.tables
        assert "name" in db4.staff
        assert db4.tvshow.rating.type == "double"
        assert (db4.tvshow.insert(), db4.tvshow.insert(name="Loriot"),
                db4.tvshow.insert(name="Il Mattatore")) == (1, 2, 3)
        assert db4(db4.tvshow).select().first().id == 1
        assert db4(db4.tvshow).select().first().name == mpfc

        db4.staff.drop()
        db4.tvshow.drop()
        db4.commit()

        dbdict5 = {"uri": DEFAULT_URI}
        db5 = DAL(dbdict5, check_reserved=['all'])
        assert db5.tables in ([], None)
        assert not (str(db5) in ("", None))

        dbdict6 = {
            "uri": DEFAULT_URI,
            "items": {
                "staff": {},
                "tvshow": {
                    "items": {
                        "name": {},
                        "rating": {
                            "type": "double"
                        }
                    }
                }
            }
        }
        db6 = DAL(dbdict6, check_reserved=['all'])

        assert len(db6["staff"].fields) == 1
        assert "name" in db6["tvshow"].fields

        assert db6.staff.insert() is not None
        assert db6(db6.staff).select().first().id == 1

        db6.staff.drop()
        db6.tvshow.drop()
        db6.commit()
Пример #25
0
def test():
    from dal import Field
    form = Form(Field('name'),Field('age'))
    print form
Пример #26
0
    def testRun(self):
        db = DAL(DEFAULT_URI, check_reserved=['all'])
        db.define_table('t1', Field('aa'))
        db.define_table('t2', Field('aa'), Field('b', db.t1))
        i1 = db.t1.insert(aa='1')
        i2 = db.t1.insert(aa='2')
        i3 = db.t1.insert(aa='3')
        db.t2.insert(aa='4', b=i1)
        db.t2.insert(aa='5', b=i2)
        db.t2.insert(aa='6', b=i2)
        self.assertEqual(
            len(db(db.t1.id == db.t2.b).select(orderby=db.t1.aa
                                               | db.t2.aa)), 3)
        self.assertEqual(
            db(db.t1.id == db.t2.b).select(orderby=db.t1.aa
                                           | db.t2.aa)[2].t1.aa, '2')
        self.assertEqual(
            db(db.t1.id == db.t2.b).select(orderby=db.t1.aa
                                           | db.t2.aa)[2].t2.aa, '6')
        self.assertEqual(
            len(db().select(db.t1.ALL,
                            db.t2.ALL,
                            left=db.t2.on(db.t1.id == db.t2.b),
                            orderby=db.t1.aa | db.t2.aa)), 4)
        self.assertEqual(
            db().select(db.t1.ALL,
                        db.t2.ALL,
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa | db.t2.aa)[2].t1.aa, '2')
        self.assertEqual(
            db().select(db.t1.ALL,
                        db.t2.ALL,
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa | db.t2.aa)[2].t2.aa, '6')
        self.assertEqual(
            db().select(db.t1.ALL,
                        db.t2.ALL,
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa | db.t2.aa)[3].t1.aa, '3')
        self.assertEqual(
            db().select(db.t1.ALL,
                        db.t2.ALL,
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa | db.t2.aa)[3].t2.aa, None)
        self.assertEqual(
            len(db().select(db.t1.aa,
                            db.t2.id.count(),
                            left=db.t2.on(db.t1.id == db.t2.b),
                            orderby=db.t1.aa,
                            groupby=db.t1.aa)), 3)
        self.assertEqual(
            db().select(db.t1.aa,
                        db.t2.id.count(),
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa,
                        groupby=db.t1.aa)[0]._extra[db.t2.id.count()], 1)
        self.assertEqual(
            db().select(db.t1.aa,
                        db.t2.id.count(),
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa,
                        groupby=db.t1.aa)[1]._extra[db.t2.id.count()], 2)
        self.assertEqual(
            db().select(db.t1.aa,
                        db.t2.id.count(),
                        left=db.t2.on(db.t1.id == db.t2.b),
                        orderby=db.t1.aa,
                        groupby=db.t1.aa)[2]._extra[db.t2.id.count()], 0)
        db.t2.drop()
        db.t1.drop()

        db.define_table('person', Field('name'))
        id = db.person.insert(name="max")
        self.assertEqual(id.name, 'max')
        db.define_table('dog', Field('name'),
                        Field('ownerperson', 'reference person'))
        db.dog.insert(name='skipper', ownerperson=1)
        row = db(db.person.id == db.dog.ownerperson).select().first()
        self.assertEqual(row[db.person.name], 'max')
        self.assertEqual(row['person.name'], 'max')
        db.dog.drop()
        self.assertEqual(len(db.person._referenced_by), 0)
        db.person.drop()
Пример #27
0
 def setUp(self):
     self.pt = Table(None, 'PseudoTable', Field('name'), Field('birthdate'))
Пример #28
0
    def testRun(self):
        db = DAL(DEFAULT_URI, check_reserved=['all'])
        for ft in ['string', 'text', 'password', 'upload', 'blob']:
            db.define_table('tt', Field('aa', ft, default=''))
            self.assertEqual(db.tt.insert(aa='x'), 1)
            self.assertEqual(db().select(db.tt.aa)[0].aa, 'x')
            db.tt.drop()
        db.define_table('tt', Field('aa', 'integer', default=1))
        self.assertEqual(db.tt.insert(aa=3), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, 3)
        db.tt.drop()
        db.define_table('tt', Field('aa', 'double', default=1))
        self.assertEqual(db.tt.insert(aa=3.1), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, 3.1)
        db.tt.drop()
        db.define_table('tt', Field('aa', 'boolean', default=True))
        self.assertEqual(db.tt.insert(aa=True), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, True)
        db.tt.drop()
        db.define_table('tt', Field('aa', 'json', default={}))
        self.assertEqual(db.tt.insert(aa={}), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, {})
        db.tt.drop()
        db.define_table('tt', Field('aa',
                                    'date',
                                    default=datetime.date.today()))
        t0 = datetime.date.today()
        self.assertEqual(db.tt.insert(aa=t0), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, t0)
        db.tt.drop()
        db.define_table(
            'tt', Field('aa', 'datetime', default=datetime.datetime.today()))
        t0 = datetime.datetime(
            1971,
            12,
            21,
            10,
            30,
            55,
            0,
        )
        self.assertEqual(db.tt.insert(aa=t0), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, t0)

        ## Row APIs
        row = db().select(db.tt.aa)[0]
        self.assertEqual(db.tt[1].aa, t0)
        self.assertEqual(db.tt['aa'], db.tt.aa)
        self.assertEqual(db.tt(1).aa, t0)
        self.assertTrue(db.tt(1, aa=None) == None)
        self.assertFalse(db.tt(1, aa=t0) == None)
        self.assertEqual(row.aa, t0)
        self.assertEqual(row['aa'], t0)
        self.assertEqual(row['tt.aa'], t0)
        self.assertEqual(row('tt.aa'), t0)

        ## Lazy and Virtual fields
        db.tt.b = Field.Virtual(lambda row: row.tt.aa)
        db.tt.c = Field.Lazy(lambda row: row.tt.aa)
        row = db().select(db.tt.aa)[0]
        self.assertEqual(row.b, t0)
        self.assertEqual(row.c(), t0)

        db.tt.drop()
        db.define_table('tt', Field('aa', 'time', default='11:30'))
        t0 = datetime.time(10, 30, 55)
        self.assertEqual(db.tt.insert(aa=t0), 1)
        self.assertEqual(db().select(db.tt.aa)[0].aa, t0)
        db.tt.drop()
Пример #29
0
 def testRun(self):
     db = DAL('sqlite:memory:')
     db.define_table('t1', Field('a'))
     db.define_table('t2', Field('a'), Field('b', db.t1))
     i1 = db.t1.insert(a='1')
     i2 = db.t1.insert(a='2')
     i3 = db.t1.insert(a='3')
     db.t2.insert(a='4', b=i1)
     db.t2.insert(a='5', b=i2)
     db.t2.insert(a='6', b=i2)
     self.assertEqual(
         len(db(db.t1.id == db.t2.b).select(orderby=db.t1.a
                                            | db.t2.a)), 3)
     self.assertEqual(
         db(db.t1.id == db.t2.b).select(orderby=db.t1.a
                                        | db.t2.a)[2].t1.a, '2')
     self.assertEqual(
         db(db.t1.id == db.t2.b).select(orderby=db.t1.a
                                        | db.t2.a)[2].t2.a, '6')
     self.assertEqual(
         len(db().select(db.t1.ALL,
                         db.t2.ALL,
                         left=db.t2.on(db.t1.id == db.t2.b),
                         orderby=db.t1.a | db.t2.a)), 4)
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.ALL,
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a)[2].t1.a, '2')
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.ALL,
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a)[2].t2.a, '6')
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.ALL,
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a)[3].t1.a, '3')
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.ALL,
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a)[3].t2.a, None)
     self.assertEqual(
         len(db().select(db.t1.ALL,
                         db.t2.id.count(),
                         left=db.t2.on(db.t1.id == db.t2.b),
                         orderby=db.t1.a | db.t2.a,
                         groupby=db.t1.a)), 3)
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.id.count(),
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a,
                     groupby=db.t1.a)[0]._extra[db.t2.id.count()], 1)
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.id.count(),
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a,
                     groupby=db.t1.a)[1]._extra[db.t2.id.count()], 2)
     self.assertEqual(
         db().select(db.t1.ALL,
                     db.t2.id.count(),
                     left=db.t2.on(db.t1.id == db.t2.b),
                     orderby=db.t1.a | db.t2.a,
                     groupby=db.t1.a)[2]._extra[db.t2.id.count()], 0)
     db.t1.drop()
     db.t2.drop()
Пример #30
0
from dal import DAL, Field
import re
db = DAL('sqlite://doxa.sqlite3')
db.define_table('dict',
                Field('word'),
                Field('definition'),
                Field('related'))

db.dict.truncate()
index = 0
for line in open("words_app.csv"):
    if line[0].isdigit() or line.startswith("#"): continue
    line = line.rstrip(",\n")
    line = line.split(",", 1)
    key, val = line[0], line[1]
    word = key
    if ')' in word:
        word = re.sub(r'\s*\(.+?\)\s*', '', word)
    db.dict.insert(word=word, definition=key, related=val)
    index += 1
db.commit()
print 'inserted %d words' % index
Пример #31
0
# configurações do servidor
TCP_IP = '0.0.0.0'
TCP_PORT = 5000
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server_socket.bind((TCP_IP, TCP_PORT))
server_socket.listen(10)
CONNECTION_LIST = [server_socket]

# criando conexão com o banco de dados
db = DAL('sqlite://storage.sqlite')

# definindo tabela de usuário
table_usuarios = db.define_table(
    'usuarios', Field('nome_usuario', notnull=True, unique=True),
    Field('senha', notnull=True), Field('pontos', 'integer', default=0))

# lista de usuários conectados
usuarios_conectados = set()


def login(nome_usuario, senha, ip_usuario):
    """
        Realiza a tentativa de login do usuário e caso bem-sucedido o adiciona
        no conjunto de usuários conectados e retorna True. Caso contrário apenas
        retorna False.
    """
    usuario = db(table_usuarios.nome_usuario == nome_usuario).select().first()
    if usuario and usuario.senha == senha:
        usuarios_conectados.add(