def entry_upvote(entry_id):
try:
query = wgdb.make_query(g.wdb, arglist=[(0, wgdb.COND_EQUAL, entry_id)])
rec = wgdb.fetch(g.wdb, query)
except Exception, e:
rec = wgdb.create_record(g.wdb, 10)
wgdb.set_field(g.wdb, rec, 0, entry_id)
def runTest(): count = 0 q = wgdb.make_query(db, arglist=[(0,wgdb.COND_EQUAL,"ee")]) record = wgdb.fetch(db, q); while record is not None: count += 1 try: record = wgdb.fetch(db, q); except wgdb.error: record = None
def show_entry(entry_id):
cur = g.db.execute('select id, title, text from entries where id=? order by id desc', (str(entry_id)))
row = cur.fetchone()
entry = dict(eid=row[0], title=row[1], text=row[2])
meta = dict(views=0, upvotes=0, downvotes=0)
try:
query = wgdb.make_query(g.wdb, arglist=[(0, wgdb.COND_EQUAL, entry_id)])
rec = wgdb.fetch(g.wdb, query)
except Exception, e:
rec = wgdb.create_record(g.wdb, 10)
wgdb.set_field(g.wdb, rec, 0, entry_id)
def make_query(self, matchrec=None, *arg, **kwarg):
"""Create a query object."""
if isinstance(matchrec, Record):
matchrec = matchrec.get__rec()
if self.locking:
self.start_write() # write lock for parameter encoding
try:
query = wgdb.make_query(self._db,
matchrec, *arg, **kwarg)
finally:
if self.locking:
self.end_write()
return query
def _set(self, key, stamp, value):
l = wgdb.start_read(self.db)
q = wgdb.make_query(self.db, arglist=[(0, wgdb.COND_EQUAL, key)])
rec = wgdb.fetch(self.db, q)
wgdb.end_read(self.db, l)
wgdb.free_query(self.db, q)
l = wgdb.start_write(self.db)
## Transaction to Cache
if not rec:
rec = wgdb.create_record(self.db, 3)
wgdb.set_field(self.db, rec, 0, key)
wgdb.set_field(self.db, rec, 1, stamp)
wgdb.set_field(self.db, rec, 2, value)
wgdb.end_write(self.db, l)
def check_matching_rows(self, col, cond, val, expected):
"""Fetch all rows where "col" "cond" "val" is true
(where cond is a comparison operator - equal, less than etc)
Check that the val matches the field value in returned records.
Check that the number of rows matches the expected value"""
query = wgdb.make_query(self.d, arglist = [(col, cond, val)])
# XXX: should check rowcount here when it's implemented
# self.assertEqual(expected, query rowcount)
cnt = 0
rec = self.fetch(query)
while rec is not None:
dbval = wgdb.get_field(self.d, rec, col)
self.assertEqual(type(val), type(dbval))
self.assertEqual(val, dbval)
cnt += 1
rec = self.fetch(query)
self.assertEqual(cnt, expected)
def test_params(self):
"""Test encoding parameters"""
marker = "This is a marker"
s1 = "ctGXioJeeUkTrxiSGaWxqFujCyWHJkmveMQXEnrHAMomjuPjKqUHlUtCVjOT"
s2 = "zjXNNGYUBjmdCrLaAaKv"
s3 = "GRvWOVYBMObOzWPqVFCt"
s4 = "#eNijRGUJbuHoJEMxRUCQ"
s5 = "http://example.com/?UQCOtBzWkdipHplZqwQF"
s6 = "KqKVvVhVcxbLssirtydJ"
s7 = "xsd:Name"
# this row shouldn't be returned by the queries (except
# the NULL query)
rec0 = wgdb.create_record(self.d, 15)
wgdb.set_field(self.d, rec0, 0, "This is not a marker")
# this row should be returned by the queries
rec = wgdb.create_record(self.d, 15)
wgdb.set_field(self.d, rec, 0, marker)
# CHARTYPE
wgdb.set_field(self.d, rec, 1, "Z", wgdb.CHARTYPE)
# DATETYPE
wgdb.set_field(self.d, rec, 2, datetime.date(1943, 2, 28))
# DOUBLETYPE
wgdb.set_field(self.d, rec, 3, 105819.387451)
# FIXPOINTTYPE
wgdb.set_field(self.d, rec, 4, 783.799, wgdb.FIXPOINTTYPE)
# INTTYPE
wgdb.set_field(self.d, rec, 5, -871043)
# NULLTYPE
wgdb.set_field(self.d, rec, 7, None)
# RECORDTYPE
wgdb.set_field(self.d, rec, 8, rec0)
# STRTYPE
wgdb.set_field(self.d, rec, 9, s1)
wgdb.set_field(self.d, rec, 10, s2, wgdb.STRTYPE)
wgdb.set_field(self.d, rec, 11, s3, ext_str="en")
# TIMETYPE
wgdb.set_field(self.d, rec, 12, datetime.time(11, 22, 33))
# URITYPE
wgdb.set_field(self.d, rec, 13, s4, wgdb.URITYPE, s5)
# XMLLITERALTYPE
wgdb.set_field(self.d, rec, 14, s6, wgdb.XMLLITERALTYPE, s7)
# CHARTYPE
query = wgdb.make_query(self.d,
arglist = [(1, wgdb.COND_EQUAL, ("Z", wgdb.CHARTYPE))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# DATETYPE
query = wgdb.make_query(self.d,
arglist = [(2, wgdb.COND_EQUAL, datetime.date(1943, 2, 28))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# DOUBLETYPE
query = wgdb.make_query(self.d,
arglist = [(3, wgdb.COND_EQUAL, 105819.387451)])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# FIXPOINTTYPE
query = wgdb.make_query(self.d,
arglist = [(4, wgdb.COND_EQUAL, (783.799, wgdb.FIXPOINTTYPE))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# INTTYPE
query = wgdb.make_query(self.d,
arglist = [(5, wgdb.COND_EQUAL, -871043)])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# NULLTYPE
query = wgdb.make_query(self.d,
arglist = [(7, wgdb.COND_EQUAL, None)])
self.assertEqual(query.res_count, 2)
self.assertIsNotNone(self.fetch(query))
self.assertIsNotNone(self.fetch(query))
self.assertIsNone(self.fetch(query))
# RECORDTYPE
query = wgdb.make_query(self.d,
arglist = [(8, wgdb.COND_EQUAL, rec0)])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# STRTYPE
query = wgdb.make_query(self.d,
arglist = [(9, wgdb.COND_EQUAL, s1)])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
query = wgdb.make_query(self.d,
arglist = [(10, wgdb.COND_EQUAL, (s2, wgdb.STRTYPE))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
query = wgdb.make_query(self.d,
arglist = [(11, wgdb.COND_EQUAL, (s3, wgdb.STRTYPE, "en"))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# TIMETYPE
query = wgdb.make_query(self.d,
arglist = [(12, wgdb.COND_EQUAL, datetime.time(11, 22, 33))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# URITYPE
query = wgdb.make_query(self.d,
arglist = [(13, wgdb.COND_EQUAL, (s4, wgdb.URITYPE, s5))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
# XMLLITERALTYPE
query = wgdb.make_query(self.d,
arglist = [(14, wgdb.COND_EQUAL, (s6, wgdb.XMLLITERALTYPE, s7))])
self.assertEqual(query.res_count, 1)
rec = self.fetch(query)
self.assertEqual(wgdb.get_field(self.d, rec, 0), marker)
self.assertIsNone(self.fetch(query))
def test_query(self):
"""Tests various queries:
- read pre-generated content;
- update content;
- read updated content;
- delete rows;
- check row count after deleting.
"""
dbsize = 10 # use a fairly small database
self.make_testdata(dbsize)
# Content check read queries
for i in range(dbsize):
val = str(10 * i)
self.check_matching_rows(0, wgdb.COND_EQUAL, val, 50*50)
for i in range(50):
val = 100 * i
self.check_matching_rows(1, wgdb.COND_EQUAL, val, dbsize*50)
for i in range(50):
val = float(1000 * i)
self.check_matching_rows(2, wgdb.COND_EQUAL, val, dbsize*50)
# Update queries
for i in range(dbsize):
c1 = str(10 * i)
query = wgdb.make_query(self.d,
arglist = [(0, wgdb.COND_EQUAL, c1)])
rec = self.fetch(query)
while rec is not None:
c2 = wgdb.get_field(self.d, rec, 1)
wgdb.set_field(self.d, rec, 1, c2 - 34555)
rec = self.fetch(query)
for i in range(50):
c2 = 100 * i - 34555
query = wgdb.make_query(self.d,
arglist = [(1, wgdb.COND_EQUAL, c2)])
rec = self.fetch(query)
while rec is not None:
c3 = wgdb.get_field(self.d, rec, 2)
wgdb.set_field(self.d, rec, 2, c3 + 177889.576)
rec = self.fetch(query)
for i in range(50):
c3 = 1000 * i + 177889.576
query = wgdb.make_query(self.d,
arglist = [(2, wgdb.COND_EQUAL, c3)])
rec = self.fetch(query)
while rec is not None:
c1val = int(wgdb.get_field(self.d, rec, 0))
c1 = str(c1val + 99)
wgdb.set_field(self.d, rec, 0, c1)
rec = self.fetch(query)
# Content check read queries, iteration 2
for i in range(dbsize):
val = str(10 * i + 99)
self.check_matching_rows(0, wgdb.COND_EQUAL, val, 50*50)
for i in range(50):
val = 100 * i - 34555
self.check_matching_rows(1, wgdb.COND_EQUAL, val, dbsize*50)
for i in range(50):
val = 1000 * i + 177889.576
self.check_matching_rows(2, wgdb.COND_EQUAL, val, dbsize*50)
# Delete query
for i in range(dbsize):
c1 = str(10 * i + 99)
arglist = [ (0, wgdb.COND_EQUAL, c1),
(1, wgdb.COND_GREATER, -30556), # 10 matching
(2, wgdb.COND_LESSTHAN, 217889.575) # 40 matching
]
query = wgdb.make_query(self.d, arglist = arglist)
rec = self.fetch(query)
while rec is not None:
wgdb.delete_record(self.d, rec)
rec = self.fetch(query)
# Database scan
self.check_db_rows(dbsize * (50 * 50 - 10 * 40))
