def test_one_table(db):
table1 = db.table('table1')
table1.insert_multiple({'int': 1, 'char': c} for c in 'abc')
assert table1.get(where('int') == 1)['char'] == 'a'
assert table1.get(where('char') == 'b')['char'] == 'b'
def test_json_readwrite(tmpdir):
"""
Regression test for issue #1
"""
path = str(tmpdir.join('test.db.json'))
# Create Flata instance
db = Flata(path, storage=JSONStorage)
# Create table test_table
tb = db.table('test_table')
item = {'data': 'data exists'}
item2 = {'data': 'data not exists'}
get = lambda s: tb.get(where('data') == s)
tb.insert(item)
assert dict(get('data exists'))['data'] == 'data exists'
assert get('data not exists') is None
tb.remove(where('data') == 'data exists')
assert get('data exists') is None
db.close()
def test_update(db):
assert db.table('t').count(where('int') == 1) == 3
db.table('t').update({'int': 2}, where('char') == 'a')
assert db.table('t').count(where('int') == 2) == 1
assert db.table('t').count(where('int') == 1) == 2
def test_query_cache_size(db):
table = db.table('table3', cache_size=1)
query = where('int') == 1
table.insert({'int': 1})
table.insert({'int': 1})
assert table.count(query) == 2
assert table.count(where('int') == 2) == 0
assert len(table._query_cache) == 1
def test_remove_with_not_default_id(tmpdir):
path = str(tmpdir.join('test.db.json'))
db = Flata(path)
table = db.table('foo', id_field='_not_default_id')
table.insert({'something': 'else'})
assert db.table('foo').count(where('something') == 'else') == 1
db.table('foo').remove(where('something') == 'else')
assert db.table('foo').all() == []
def test_unicode_memory(db):
unic_str = 'ß'.decode('utf-8')
byte_str = 'ß'
db.table('t').insert({'value': unic_str})
assert db.table('t').contains(where('value') == byte_str)
assert db.table('t').contains(where('value') == unic_str)
db.purge_tables()
db.table('t').insert({'value': byte_str})
assert db.table('t').contains(where('value') == byte_str)
assert db.table('t').contains(where('value') == unic_str)
def test_update_with_external_cache(db):
_cache = CachingMiddleware(MemoryStorage)()
db = Flata(cache=_cache)
tb = db.table('t')
tb.insert({'int': 1, 'char': 'a'})
assert tb.count(where('int') == 1) == 1
db2 = Flata(cache=_cache)
tb = db2.table('t')
db2.table('t').update({'int': 2}, where('char') == 'a')
assert db2.table('t').count(where('int') == 2) == 1
def test_unicode_json(tmpdir):
unic_str1 = 'a'.decode('utf-8')
byte_str1 = 'a'
unic_str2 = 'ß'.decode('utf-8')
byte_str2 = 'ß'
path = str(tmpdir.join('test.db.json'))
with Flata(path) as _db:
_db.purge_tables()
_db.table('t').insert({'value': byte_str1})
_db.table('t').insert({'value': byte_str2})
assert _db.table('t').contains(where('value') == byte_str1)
assert _db.table('t').contains(where('value') == unic_str1)
assert _db.table('t').contains(where('value') == byte_str2)
assert _db.table('t').contains(where('value') == unic_str2)
with Flata(path) as _db:
_db.purge_tables()
_db.table('t').insert({'value': unic_str1})
_db.table('t').insert({'value': unic_str2})
assert _db.table('t').contains(where('value') == byte_str1)
assert _db.table('t').contains(where('value') == unic_str1)
assert _db.table('t').contains(where('value') == byte_str2)
assert _db.table('t').contains(where('value') == unic_str2)
def test_insert(db):
db.purge_tables()
tb = db.table('t')
tb.insert({'int': 1, 'char': 'a'})
assert tb.count(where('int') == 1) == 1
db.purge_tables()
db.table('t').insert({'int': 1, 'char': 'a'})
db.table('t').insert({'int': 1, 'char': 'b'})
db.table('t').insert({'int': 1, 'char': 'c'})
assert db.table('t').count(where('int') == 1) == 3
assert db.table('t').count(where('char') == 'a') == 1
def test_unique_ids(tmpdir):
"""
:type tmpdir: py._path.local.LocalPath
"""
path = str(tmpdir.join('test.db.json'))
# Verify ids are unique when reopening the DB and inserting
with Flata(path) as _db:
_db.table('t').insert({'x': 1})
with Flata(path) as _db:
_db.table('t').insert({'x': 1})
with Flata(path) as _db:
data = _db.table('t').all()
assert data[0].id != data[1].id
# Verify ids stay unique when inserting/removing
with Flata(path) as _db:
_db.purge_tables()
_db.table('t').insert_multiple({'x': i} for i in range(5))
_db.table('t').remove(where('x') == 2)
assert len(_db.table('t').all()) == 4
ids = [e.id for e in _db.table('t').all()]
assert len(ids) == len(set(ids))
def post_to_space(objectset, database, logdb, bot_token, room_id):
sql_query = Query()
for item in objectset:
incident_id_db = item["IncidentId"]
last_updated_db = item["LastUpdated"]
entry_exist = database.search((sql_query.IncidentId == incident_id_db))
#If entry is missing in the database. Insert into database and send to Webex.
if not entry_exist:
sendrespone = send_it(bot_token, room_id, item)
msg_id = sendrespone.json()
msg_id = msg_id["id"]
item['msgId'] = msg_id
database.insert(item)
logdb.insert(
log.log("New insert on object with incidentID of: " +
incident_id_db))
else:
new_entries = database.search(
(sql_query.IncidentId == incident_id_db)
& (sql_query.LastUpdated < last_updated_db))
#Update new entries that have newer lastUpdated and send to Webex.
if new_entries:
database.update(item, where('IncidentId') == incident_id_db)
send_it(bot_token, room_id, item)
logdb.insert(
log.log("New update on object with incidentID of: " +
incident_id_db))
def test_update_returns_ids(db):
db.purge_tables()
assert db.table('t').insert({
'int': 1,
'char': 'a'
}) == {
'id': 1,
'char': 'a',
'int': 1
}
assert db.table('t').insert({
'int': 1,
'char': 'a'
}) == {
'id': 2,
'char': 'a',
'int': 1
}
assert db.table('t').update({'char': 'b'},
where('int') == 1) == ([1, 2], [{
'id': 1,
'char': 'b',
'int': 1
}, {
'id': 2,
'char': 'b',
'int': 1
}])
def update_meta_data():
metadataTable.update(
{
version: get_updated_minor_version(),
ts_modified: ts_now()
},
where(uid) == metadata_uid)
def testids_json(tmpdir):
path = str(tmpdir.join('test.db.json'))
with Flata(path) as _db:
_db.purge_tables()
assert _db.table('t').insert({
'int': 1,
'char': 'a'
}) == {
'id': 1,
'char': 'a',
'int': 1
}
assert _db.table('t').insert({
'int': 1,
'char': 'a'
}) == {
'id': 2,
'char': 'a',
'int': 1
}
_db.purge_tables()
assert _db.table('t').insert_multiple([{
'int': 1,
'char': 'a'
}, {
'int': 1,
'char': 'b'
}, {
'int': 1,
'char': 'c'
}]) == [{
'id': 1,
'char': 'a',
'int': 1
}, {
'id': 2,
'char': 'b',
'int': 1
}, {
'id': 3,
'char': 'c',
'int': 1
}]
assert _db.table('t').contains(ids=[1, 2])
assert not _db.table('t').contains(ids=[88])
_db.table('t').update({'int': 2}, ids=[1, 2])
assert _db.table('t').count(where('int') == 2) == 2
el = _db.table('t').all()[0]
assert _db.table('t').get(id=el.id) == el
assert _db.table('t').get(id=float('NaN')) is None
_db.table('t').remove(ids=[1, 2])
assert len(_db.table('t').all()) == 1
def test_multiple_tables(db):
table1 = db.table('table1')
table2 = db.table('table2')
table3 = db.table('table3')
table1.insert({'int': 1, 'char': 'a'})
table2.insert({'int': 1, 'char': 'b'})
table3.insert({'int': 1, 'char': 'c'})
assert table1.count(where('char') == 'a') == 1
assert table2.count(where('char') == 'b') == 1
assert table3.count(where('char') == 'c') == 1
db.purge_tables()
assert len(table1) == 0
assert len(table2) == 0
assert len(table3) == 0
def test_lru_cache(db):
# Test integration into Flata
table = db.table('table3', cache_size=2)
query = where('int') == 1
table.search(query)
table.search(where('int') == 2)
table.search(where('int') == 3)
assert query not in table._query_cache
table.remove(where('int') == 1)
assert not table._query_cache.lru
table.search(query)
assert len(table._query_cache) == 1
table.clear_cache()
assert len(table._query_cache) == 0
def countlifepersecond():
global t
getnewdata = tb.search(Query().uid == after.id)
getnewstartpoint = getnewdata[0]['time']
timetoaddit = getnewstartpoint
timetoaddit += 1
print(str(timetoaddit) + ' ' + str(after.name))
final_time = timetoaddit
tb.update({'time': final_time}, where('time') == getnewstartpoint )
t = threading.Timer(1, countlifepersecond)
t.start()
def update(curr_uid, new_obj):
"""
Updates a row in FlataDB.
Input: uid, a new object row as a dict.
"""
if exists(curr_uid):
curr = recordsTable.search(q.uid == curr_uid)[0]
curr[ts_modified] = ts_now()
recordsTable.update(enrich_records({
**curr,
**new_obj
}),
where(uid) == curr_uid)
def test_insert_multiple(db):
db.purge_tables()
# Insert multiple from list
db.table('t').insert_multiple([{
'int': 1,
'char': 'a'
}, {
'int': 1,
'char': 'b'
}, {
'int': 1,
'char': 'c'
}])
assert db.table('t').count(where('int') == 1) == 3
assert db.table('t').count(where('char') == 'a') == 1
# Insert multiple from generator function
def generator():
for j in range(10):
yield {'int': j}
db.purge_tables()
db.table('t').insert_multiple(generator())
for i in range(10):
assert db.table('t').count(where('int') == i) == 1
assert db.table('t').count(where('int').exists()) == 10
# Insert multiple from inline generator
db.purge_tables()
db.table('t').insert_multiple({'int': i} for i in range(10))
for i in range(10):
assert db.table('t').count(where('int') == i) == 1
def query(**kwargs):
_dbf = kwargs[CONFIG_DB] or DEFAULT_DB
_storage = MemoryStorage if kwargs[
CONFIG_STORAGE] == MEMORY_STORAGE else JSONStorage
_cache = kwargs.pop(CONFIG_CACHE, None)
_tb = kwargs[RESOURCE_DOCUMENT]
_id = kwargs[RESOURCE_QUERY].pop(RESOURCE_ID) \
if RESOURCE_QUERY in kwargs and RESOURCE_ID in kwargs[RESOURCE_QUERY] else None
_embed = kwargs[RESOURCE_QUERY].pop(RESOURCE_EMBED) \
if RESOURCE_QUERY in kwargs and RESOURCE_EMBED in kwargs[RESOURCE_QUERY] else None
_expand = kwargs[RESOURCE_QUERY].pop(RESOURCE_EXPAND) \
if RESOURCE_QUERY in kwargs and RESOURCE_EXPAND in kwargs[RESOURCE_QUERY] else None
_query = extract_query(
**kwargs[RESOURCE_QUERY]) if RESOURCE_QUERY in kwargs else None
with Flata(_dbf, storage=_storage, cache=_cache) as db:
tb = db.table(_tb)
if _id:
obj = tb.get(id=_id)
if _embed and obj:
embed = db.table(_embed)
embed_id = _tb[:-1] + 'Id'
embeds = embed.search(where(embed_id) == _id)
obj[_embed] = embeds
if _expand and obj:
expand_id_field = expand_field = _expand[:-1] + 'Id'
if expand_id_field in obj:
expand_id = obj[expand_id_field]
expand = db.table(_expand)
expand_field = _expand[:-1]
expand_elem = expand.get(id=_id)
obj[expand_field] = expand_elem
elif _query:
obj = tb.search(_query)
else:
obj = tb.all()
return obj
def test_gc(tmpdir):
path = str(tmpdir.join('test.db.json'))
db = Flata(path)
table = db.table('foo')
table.insert({'something': 'else'})
table.insert({'int': 13})
assert len(table.search(where('int') == 13)) == 1
assert table.all() == [{
'id': 1,
'something': 'else'
}, {
'id': 2,
'int': 13
}]
db.close()
def test_queries_where(db):
assert len(db.table('t').all()) == 3
assert not db.table('t')._query_cache
assert len(db.table('t').search(where('int') == 1)) == 3
assert len(db.table('t')._query_cache) == 1
assert len(db.table('t').search(
where('int') == 1)) == 3 # Query result from cache
assert len(db.table('t').search(~(where('char') == 'a'))) == 2
assert len(
db.table('t').search((where('int') == 1)
& (where('char') == 'a'))) == 1
assert len(
db.table('t').search((where('char') == 'b')
| (where('char') == 'a'))) == 2
def completeTodo():
# check that length
if len(args) != 3:
errorLog("invalid number of arguments passed for complete command")
else:
try:
# check if the value is a number
n = int(args[2])
todosLength = len(db.get('todos'))
# check if the correct length of values has been passed
if (n > todosLength):
errorLog("invalid number passed for complete command")
else:
# update the todo item marked as complete
db.get('todos').update({'complete': True}, where('id') == n)
except ValueError:
errorLog("please provide a valid number for complete command")
def test_query_memory_storage():
db = Flata(storage=MemoryStorage)
db.table('t').insert_multiple([{
'name': 'foo',
'value': 42
}, {
'name': 'bar',
'value': -1337
}])
query = where('value') > 0
results = db.table('t').search(query)
assert len(results) == 1
# Now, modify the result ist
results.extend([1])
assert db.table('t').search(query) == [{
'id': 1,
'name': 'foo',
'value': 42
}]
def test_update_transform(db):
def increment(field):
def transform(el):
el[field] += 1
return transform
def delete(field):
def transform(el):
del el[field]
return transform
assert db.table('t').count(where('int') == 1) == 3
db.table('t').update(increment('int'), where('char') == 'a')
db.table('t').update(delete('char'), where('char') == 'a')
assert db.table('t').count(where('int') == 2) == 1
assert db.table('t').count(where('char') == 'a') == 0
assert db.table('t').count(where('int') == 1) == 2
def test_update_ids(db):
db.table('t').update({'int': 2}, ids=[1, 2])
assert db.table('t').count(where('int') == 2) == 2
def test_get(db):
item = db.table('t').get(where('char') == 'b')
assert item['char'] == 'b'
def test_count(db):
assert db.table('t').count(where('int') == 1) == 3
assert db.table('t').count(where('char') == 'd') == 0
def test_contains(db):
assert db.table('t').contains(where('int') == 1)
assert not db.table('t').contains(where('int') == 0)
def test_get_idempotent(db):
u = db.table('t').get(where('int') == 1)
z = db.table('t').get(where('int') == 1)
assert u == z
