def test_dobject_dmerge(): # orginal data ASet = dset(t_a) ds = ASet([t_a(a=101, b=102, c=103, d=104, e=105), t_a(a=201, b=202, c=203, d=204, e=205)]) t_a1 = t_a._re(_ignore=['c', 'e']) A1Set = dset(t_a1) ds1 = A1Set(ds) dmerge(ds1) dbc << "SELECT * FROM t_a" ds0 = A1Set(dbc) # original ds1 = A1Set(ds0) # to be modified ds1 += [t_a1(a=301, b=302, d=304, f=306)] # insert a new item ds1[t_a(a=101, b=102)].f = 5555 # update the first item del ds1[t_a(a=201, b=202)] # delete the 2nd item print('ORIGINAL:', ds0) print('MODIFIED:', ds1) dmerge(ds1, ds0)
def test_dset_declaration3(): class A(dobject): a = datt(int) b = datt(int) __dobject_key__ = [a] class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a) s1 = BSet([B(x=1, y=11), B(x=2, y=22)]) assert s1.a is None s1 = BSet(s1, a = 101) assert s1.a == 101 #------------------------------------------------------------------- class B(dobject): a = datt(int) x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a) s1 = BSet([B(x=1, y=11), B(x=2, y=22)], a=101) sl = list(s1) assert s1.a == 101 and sl[0].a == 101 and sl[1].a == 101 class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x]
def test_dset_declaration1(): class A(dobject): a = datt(int) b = datt(int) __dobject_key__ = [a] class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] # A <>---> B BSet = dset(B, _key=A.a) assert tuple(BSet.__dobject_key__) == ('a', ) assert BSet.__dominion_class__ == A assert BSet.a != A.a assert BSet.a.owner_class == BSet BSet = dset(B, _dominion=A, _key=['a']) assert tuple(BSet.__dobject_key__) == ('a', ) assert BSet.__dominion_class__ == A assert BSet.a != A.a assert BSet.a.owner_class == BSet with pytest.raises(ValueError): BSet = dset(B, _key=['a']) # the attribute a is undefined BSet = dset(B, _key=dict(a=datt(int))) assert tuple(BSet.__dobject_key__) == ('a', ) assert BSet.__dominion_class__ is None assert BSet.a != A.a assert BSet.a.owner_class == BSet
def test_dset_links_1(): class A(dobject): a = datt(int) b = datt(int) __dobject_key__ = [a] class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a, a='y') # link s1 = BSet([B(x=1, y=11), B(x=2, y=22)], a=101) sl = list(s1) assert s1.a == 101 and sl[0].y == 101 and sl[1].y == 101 print(s1) #------------------------------------------------------------------- class B(dobject): a = datt(int) # the same name with dset key x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a, a='y') # link s1 = BSet([B(x=1, y=11), B(x=2, y=22)], a=101) sl = list(s1) assert s1.a == 101 and sl[0].y == 101 and sl[1].y == 101 assert sl[0].a is None and sl[1].a is None print(s1)
def test_dset_declaration3(): class A(dobject): a = datt(int) b = datt(int) __dobject_key__ = [a] class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a) s1 = BSet([B(x=1, y=11), B(x=2, y=22)]) assert s1.a is None s1 = BSet(s1, a=101) assert s1.a == 101 #------------------------------------------------------------------- class B(dobject): a = datt(int) x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B, _key=A.a) s1 = BSet([B(x=1, y=11), B(x=2, y=22)], a=101) sl = list(s1) assert s1.a == 101 and sl[0].a == 101 and sl[1].a == 101 class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x]
def test_dobject_dmerge(): # orginal data ASet = dset(t_a) ds = ASet([ t_a(a=101, b=102, c=103, d=104, e=105), t_a(a=201, b=202, c=203, d=204, e=205) ]) t_a1 = t_a._re(_ignore=['c', 'e']) A1Set = dset(t_a1) ds1 = A1Set(ds) dmerge(ds1) dbc << "SELECT * FROM t_a" ds0 = A1Set(dbc) # original ds1 = A1Set(ds0) # to be modified ds1 += [t_a1(a=301, b=302, d=304, f=306)] # insert a new item ds1[t_a(a=101, b=102)].f = 5555 # update the first item del ds1[t_a(a=201, b=202)] # delete the 2nd item print('ORIGINAL:', ds0) print('MODIFIED:', ds1) dmerge(ds1, ds0)
def test_dset_declaration1(): class A(dobject): a = datt(int) b = datt(int) __dobject_key__ = [a] class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] # A <>---> B BSet = dset(B, _key=A.a) assert tuple(BSet.__dobject_key__) == ('a',) assert BSet.__dominion_class__ == A assert BSet.a != A.a assert BSet.a.owner_class == BSet BSet = dset(B, _dominion=A, _key=['a']) assert tuple(BSet.__dobject_key__) == ('a',) assert BSet.__dominion_class__ == A assert BSet.a != A.a assert BSet.a.owner_class == BSet with pytest.raises(ValueError): BSet = dset(B, _key=['a']) # the attribute a is undefined BSet = dset(B, _key=dict(a=datt(int))) assert tuple(BSet.__dobject_key__) == ('a',) assert BSet.__dominion_class__ is None assert BSet.a != A.a assert BSet.a.owner_class == BSet
def test(): s = seq_po() # s.value =100 print('100, ', bool(s)) s.value = '100' print('200, ', bool(s)) print('ddd %d' % s) mm = mm_po('P003') print(mm) dbc << 'SELECT %s' dbc << (1,) dbc << (2,) dbc << [(3,), (4,)] dbc << '' dbc << 'SELECT %s' << (200,) dbc << 'select 100' s1 = dset(item_type=mm_po) s1.append(mm_po(po_no='P001', po_date=dt.date(2015,7,1), notes='abc')) s1.append(mm_po(po_no='P002', po_date=dt.date(2015,7,2), notes='xyz')) s1.append(mm_po(po_no='P004', po_date=dt.date(2015,7,4), notes='hij')) s1.append(mm_po(po_no='P003', po_date=dt.date(2015,7,3), notes='efg')) dmerge(s1, None) s2 = s1.copy() s2[0].notes = 'abc21' s2[2].po_date = dt.date(2015, 6, 2) s2[2].notes = 'abc22' dmerge(s2, s1) s3 = s2.copy() del s3[1] dmerge(s3, s2) po_no = 'P001' dbc << 'SELECT * FROM mm_po WHERE po_no=%s' po_old = dset(mm_po, dbc << (po_no,)) po_new = po_old.copy() po_new[0].notes = 'test2-123' dmerge(po_new, po_old) print(po_new)
def test_sequence(): r1 = t_a(b=101) r2 = t_a(b=102) print('R1: ', r1, '\nR2: ', r2, sep='') assert isinstance(r1.a, seq_test) and isinstance(r2.a, seq_test) assert r1.a is not r2.a assert r1.a != r2.a ASet = dset(t_a) s1 = ASet() s1 += [r1, r2] dmerge(s1) print('R1: ', r1, '\nR2: ', r2, sep='') assert isinstance(r1.a, seq_test) and isinstance(r2.a, seq_test) assert r1.a is not r2.a assert r1.a != r2.a assert r1.a.value == 10000 and int(r1.a) == 10000 assert r2.a.value == 10001 and int(r2.a) == 10001 dbc << "SELECT * FROM t_a ORDER BY a" s1 = ASet(dbc) sl = list(s1) print(s1) assert isinstance(sl[0].a, seq_test) assert sl[0].a.value == 10000 assert sl[0].a == r1.a
def get_update_labels(repos_sn, label_texts, label_type): found_labels = find_labels(repos_sn, label_texts, label_type) now = datetime.utcnow(); LabelSet = dset(ts_label) new_labels = LabelSet() for text in label_texts: if text in found_labels: continue label = ts_label(repos_sn=repos_sn, label_sn=ts_label_seqno()) label.label=text label.type = label_type label.created_ts = now label.updated_ts = now new_labels._add(label) dmerge(new_labels) for item in new_labels: found_labels[item.label] = item.label_sn return found_labels
async def test_recall2(db, module_dtables): ASet = dset(t_b, _key=dict(a=datt(int))) # define a key of dset ds1 = ASet(a=1) ds1 += [t_b(b=12, c=13, d= 14), t_b(b=22, c=23, d=24)] await dmerge(ds1) db << 'SELECT 1 as sn FROM t_b' await db ds2 = ASet(a=2) print(333, ds2) ds2 += [t_b(b=32, c=33, d= 34), t_b(b=42, c=43, d=44)] await dmerge(ds2) ds1 = await drecall(ASet(a=1)) assert len(ds1) == 2 ds1 += [t_b(b=12, c=113, d=114), t_b(b=62, c=63, d=64)] del ds1[t_b(b=22)] with pytest.raises(KeyError): del ds1[t_b(b=55)] ds0 = await drecall(ASet(a=1)) print("O: ", ds0) print("N: ", ds1) await dmerge(ds1, ds0) ds2 = await drecall(ASet(a=1)) assert ds2[0].c == ds1[0].c assert ds2[1].c == ds1[1].c
async def test_dmerge(db, module_dtables): # schema = DBSchema() # schema.add_module(inspect.getmodule(t_a)) # await schema.drop() # await schema.create() # orginal data ASet = dset(t_a) ds = ASet([t_a(a=101, b=102, c=103, d=104, e=105), t_a(a=201, b=202, c=203, d=204, e=205)]) t_a1 = t_a._re(_ignore=['c', 'e']) A1Set = dset(t_a1) ds1 = A1Set(ds) await dmerge(ds1) # return db << "SELECT * FROM t_a" await db ds0 = A1Set(db) # original ds1 = A1Set(ds0) # to be modified ds1 += [t_a1(a=301, b=302, d=304, f=306)] # insert a new item ds1[t_a(a=101, b=102)].f = 5555 # update the first item del ds1[t_a(a=201, b=202)] # delete the 2nd item print('ORIGINAL:', ds0) print('MODIFIED:', ds1) await dmerge(ds1, ds0) SQL("SELECT * FROM t_a ORDER BY a,b") >> db ds2 = A1Set(await db) print("SELECTED:", ds2) assert ds1[0] == ds2[0] and ds1[0].f == ds2[0].f assert ds1[1] == ds2[1]
def case2(page: DPage) -> DSet[test_a] : print(3444, page) page = DPage(start=3, limit=5, sortable='+sn,-line') ASet = dset(test_a, _key=dict(sn=datt(int))) ds1 = ASet(sn=101, _page=page) for i in range(3,8): ds1 += [test_a(line=i, name='L%03d' % i)] return ds1
def case2(page: DPage) -> DSet[test_a]: print(3444, page) page = DPage(start=3, limit=5, sortable='+sn,-line') ASet = dset(test_a, _key=dict(sn=datt(int))) ds1 = ASet(sn=101, _page=page) for i in range(3, 8): ds1 += [test_a(line=i, name='L%03d' % i)] return ds1
async def test_recall_without_dset_key(db, module_dtables): ASet = dset(t_b) # define a key of dset ds1 = ASet() ds1 += [t_b(a=1, b=12, c=13, d= 14), t_b(a=1, b=22, c=23, d=24)] ds1 += [t_b(a=1, b=32, c=33, d= 34), t_b(a=1, b=42, c=43, d=44)] await dmerge(ds1) ds2 = await drecall(ASet()) assert len(ds2) == 4 print(ds2)
def test_recall_without_dset_key(): ASet = dset(t_b) # define a key of dset ds1 = ASet() ds1 += [t_b(a=1, b=12, c=13, d=14), t_b(a=1, b=22, c=23, d=24)] ds1 += [t_b(a=1, b=32, c=33, d=34), t_b(a=1, b=42, c=43, d=44)] dmerge(ds1) ds2 = drecall(ASet()) assert len(ds2) == 4 print(ds2)
def test_dset_declaration2(): class B(dobject): x = datt(int) y = datt(int) with pytest.raises(TypeError): BSet = dset(B) class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = x BSet = dset(B) s1 = BSet([B(x=1, y=11), B(x=2, y=22)]) s1 += [B(x=2, y=22)] s1 += [B(x=3, y=23)] with pytest.raises(ValueError): s1 = BSet(s1, e=1)
def test_recall1(): ASet = dset(t_b, _key=dict(a=datt(int))) # define a key of dset ds1 = ASet(a=11) ds1 += [t_b(b=12, c=13, d= 14), t_b(b=22, c=23, d=24)] dmerge(ds1) r1 = drecall(t_b(a=11, b=12)) assert r1.a == 11 and r1.b == 12 and r1.c == 13 r1 = drecall(t_b(a=99, b=12)) # no found and return empty dobject assert r1 is not None and not bool(r1)
def test_recall1(): ASet = dset(t_b, _key=dict(a=datt(int))) # define a key of dset ds1 = ASet(a=11) ds1 += [t_b(b=12, c=13, d=14), t_b(b=22, c=23, d=24)] dmerge(ds1) r1 = drecall(t_b(a=11, b=12)) assert r1.a == 11 and r1.b == 12 and r1.c == 13 r1 = drecall(t_b(a=99, b=12)) # no found and return empty dobject assert r1 is not None and not bool(r1)
async def test_func1(db, event_loop): db << """\ SELECT 1 as name """ async for r in db: print(r) db << """\ DROP TABLE IF EXISTS test_123 """ await db # db << """\ CREATE TABLE IF NOT EXISTS test_123 ( sn INTEGER, name TEXT ) """ await db data = [(1, 'a'), (2, 'b'), (3, 'c')] table_name = "test_123" for sn, name in data: db << f"INSERT INTO {table_name} (sn, name) VALUES ({{sn}}, {{name}})" # dbconn << f"" await db data = [{"sn":4, "name":'d'}, {"sn":5, "name":'e'}, {"sn":6, "name":'f'}] db << "INSERT INTO test_123 (sn, name) VALUES ({sn}, {name})" await db(data) db << SQL('SELECT sn, name FROM test_123;') async for r in db: print(r) db << SQL('SELECT sn, name FROM test_123') await db for r in db: print(r) class B(dobject): sn = datt(int) name = datt(str) __dobject_key__ = [sn] db << SQL('SELECT sn, name FROM test_123') await db BSet = dset(B) bset = BSet(db) print(bset)
def test_diff(): from domainics.db.dmerge import _dtable_diff # orginal data ASet = dset(t_a) ds = ASet([ t_a(a=10010, b=10011, c=10012, d=10013, e=10014), t_a(a=10010, b=10021, c=10022, d=10023, e=10024), ]) # constrained information in this domain, # reshape t_a to t_a1 t_a1 = t_a._re(_ignore=('c', 'e'), _name='t_a1') A1Set = dset(t_a1) ds1 = A1Set(ds) ds0 = A1Set() inslst, updlst, dellst = _dtable_diff(ds1, ds0) assert len(inslst.values) == 2 and len(inslst.pkey_values) == 2 assert len(updlst.values) == 0 and len(updlst.pkey_values) == 0 assert len(dellst.pkey_values) == 0 # print('INS:\n', inslst, '\nUPD:\n', updlst, '\nDEL:\n', dellst) ds2 = A1Set(ds1) # clone it ds2[t_a(a=10010, b=10011)].f = 100 del ds2[t_a(a=10010, b=10021)] inslst, updlst, dellst = _dtable_diff(ds2, ds1) print('INS:\n', inslst, '\nUPD:\n', updlst, '\nDEL:\n', dellst) assert len(inslst.values) == 0 and len(inslst.pkey_values) == 0 assert len(updlst.values) == 1 and len(updlst.pkey_values) == 1 assert len(dellst.pkey_values) == 1
def list_repos_briefs(source:str, page: DPage): """取得用户信息""" user_sn = webreq.principal_id dbc << """ SELECT r.* FROM ts_repos r JOIN ts_repos_user USING (repos_sn) WHERE user_sn=%(user_sn)s """ dbc << dict(user_sn=user_sn) ReposSet = dset(ts_repos) return ReposSet(dbc)
def test2(): mm = mm_po(po_no='P003') s1 = dset(item_type=mm_po) s1.append(mm_po(po_no='P201')) s1.append(mm_po(po_no='P202')) s1.append(mm_po(po_no='P203')) dmerge(s1) s2 = s1.copy() s2[0].vendor_sn = vendor_seq() s2[1].vendor_sn = vendor_seq() dmerge(s2, s1) print(s2)
def test_dset_clone(): class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B) ds1 = BSet([B(x=11, y=12), B(x=21,y=22)]) ds2 = BSet(ds1) ls1 = list(ds1) ls2 = list(ds2) ls2[0].y = 102 assert ls1[0].y == 12 and ls2[0].y == 102
def test_dset_clone(): class B(dobject): x = datt(int) y = datt(int) __dobject_key__ = [x] BSet = dset(B) ds1 = BSet([B(x=11, y=12), B(x=21, y=22)]) ds2 = BSet(ds1) ls1 = list(ds1) ls2 = list(ds2) ls2[0].y = 102 assert ls1[0].y == 12 and ls2[0].y == 102
def test_array(): ASet = dset(t_a) s1 = ASet() r1 = t_a(a=1) s1 += [r1] s1[0].b = ['a', 'b'] assert s1[0].b == ['a', 'b'] dmerge(s1) dbc << "SELECT * FROM t_a ORDER BY a" s2 = ASet(dbc) assert s2[0].b == ['a', 'b'] print(s2)
async def test_array(db, module_dtables): ASet = dset(t_a) s1 = ASet() r1 = t_a(a=1) s1 += [r1] s1[0].b = ['a', 'b'] assert s1[0].b == ['a', 'b'] await dmerge(s1) await (db << "SELECT * FROM t_a ORDER BY a") s2 = ASet(db) assert s2[0].b == ['a', 'b'] print(s2)
def test_recall2(): ASet = dset(t_b, _key=dict(a=datt(int))) # define a key of dset ds1 = ASet(a=1) ds1 += [t_b(b=12, c=13, d=14), t_b(b=22, c=23, d=24)] dmerge(ds1) ds2 = ASet(a=2) ds2 += [t_b(b=32, c=33, d=34), t_b(b=42, c=43, d=44)] dmerge(ds2) ds1 = drecall(ASet(a=1)) ds1 += [t_b(b=12, c=113, d=114), t_b(b=62, c=63, d=64)] del ds1[t_b(b=22)] with pytest.raises(KeyError): del ds1[t_b(b=55)] ds0 = drecall(ASet(a=1)) print("O: ", ds0) print("N: ", ds1) dmerge(ds1, ds0)
def test_recall2(): ASet = dset(t_b, _key=dict(a=datt(int))) # define a key of dset ds1 = ASet(a=1) ds1 += [t_b(b=12, c=13, d= 14), t_b(b=22, c=23, d=24)] dmerge(ds1) ds2 = ASet(a=2) ds2 += [t_b(b=32, c=33, d= 34), t_b(b=42, c=43, d=44)] dmerge(ds2) ds1 = drecall(ASet(a=1)) ds1 += [t_b(b=12, c=113, d=114), t_b(b=62, c=63, d=64)] del ds1[t_b(b=22)] with pytest.raises(KeyError): del ds1[t_b(b=55)] ds0 = drecall(ASet(a=1)) print("O: ", ds0) print("N: ", ds1) dmerge(ds1, ds0)
def test_case2(): ASet = dset(test_a, _key=dict(sn=datt(int))) ds1 = ASet(sn=101) for i in range(10): ds1 += [test_a(line=i, name='L%03d' % i)] ds1 = ASet(sn=202) for i in range(10): ds1 += [test_a(line=i, name='L%03d' % i)] dmerge(ds1) page = DPage(start=2, limit=3, sortable='+sn,-line') ds1 = ASet(sn=101, _page=page) ds2 = drecall(ds1) print('ds: ', ds2) assert len(ds2) == 3 assert ds2[test_a(line=7)].line == 7 assert not ds2[test_a(line=4)] assert not ds2[test_a(line=8)]
class A(dobject): a_sn = datt(int) b = datt(dset(B)) __dobject_key__ = [a_sn]
def list_user(page: DPage) -> DSet[UserInfo]: """取得用户信息""" UserSet = dset(UserInfo) users = drecall(UserSet(_page=page)) return users
def update_category(repos_sn, json_arg): """ """ now = datetime.utcnow(); text = json_arg['text']; print(repos_sn, text) labels = [] level_1 = '' for ln in re.split('[\n\r]+', text): m = re.search('(^\s+)', ln) sp_num = m.end() if m else 0 if sp_num > 0: labels.append(level_1 + '/' + ln.strip()) else: level_1 = ln.strip() labels.append(level_1) old_labels = get_repos_categories(repos_sn) old_set = set(old_labels.keys()) new_set = set(labels) lbl_com_set = old_set.intersection(new_set) lbl_ins_set = new_set.difference(lbl_com_set) new_labels = get_update_labels(repos_sn, lbl_ins_set, 'C') sn_com_list = set(old_labels[n]['label_sn'] for n in lbl_com_set) sn_ins_list = set(int(new_labels[n]) for n in lbl_ins_set) orig_categories = drecall(ts_repos_categories(repos_sn=repos_sn)) categories = ts_repos_categories(repos_sn=repos_sn) categories.labels = sorted(int(x) for x in sn_ins_list.union(sn_com_list)) categories.updated_ts = now dmerge(categories, orig_categories) ##----------------------------------------------------------------------- ## 保留文本指定的顺序 orders = {} for i, lbl in enumerate(labels): orders[lbl] = i + 1 dbc << """\ WITH s AS ( SELECT UNNEST(labels) AS label_sn FROM ts_repos_categories WHERE repos_sn = %(repos_sn)s ) SELECT t.* FROM ts_label t JOIN s USING(label_sn) """ dbc << dict(repos_sn=repos_sn) LabelSet = dset(ts_label) old_label_set = LabelSet(dbc) label_set = LabelSet() for r in old_label_set: r = ts_label(r) r.props = copy.deepcopy(r.props) # 需要复制,否则修改的是旧的 label_set._add(r) for r in label_set: ordnum = orders[r.label] if r.props: if 'order' in r.props and r.props['order'] == ordnum: continue r.props['order'] = ordnum else: pass r.props = {'order': ordnum} r.updated_ts = now dmerge(label_set, old_label_set)
class Bill(dobject): sn = datt(int) __dobject_key__ = [sn] items = datt(dset(Item, sn='bill_sn'), doc="")
class A(dobject): a = datt(int) x = datt(dset(B)) __dobject_key__ = [a]