cubicweb/dataimport/test/test_massive_store.py
changeset 11777 5b535fe2f364
parent 11774 51c160677afe
child 11778 9847a097266e
equal deleted inserted replaced
11776:b49684ddd543 11777:5b535fe2f364
    31     startpgcluster(__file__)
    31     startpgcluster(__file__)
    32 
    32 
    33 
    33 
    34 def tearDownModule(*args):
    34 def tearDownModule(*args):
    35     stoppgcluster(__file__)
    35     stoppgcluster(__file__)
       
    36 
       
    37 
       
    38 def all_indexes(cnx):
       
    39     crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
       
    40     return set(r[0] for r in crs.fetchall())
    36 
    41 
    37 
    42 
    38 class MassiveObjectStoreWithCustomMDGenStoreTC(
    43 class MassiveObjectStoreWithCustomMDGenStoreTC(
    39         test_stores.NoHookRQLObjectStoreWithCustomMDGenStoreTC):
    44         test_stores.NoHookRQLObjectStoreWithCustomMDGenStoreTC):
    40     configcls = PostgresApptestConfiguration
    45     configcls = PostgresApptestConfiguration
   116             store.commit()
   121             store.commit()
   117             eid, etname = cnx.execute('Any X, TN WHERE X timezone TZ, X is T, '
   122             eid, etname = cnx.execute('Any X, TN WHERE X timezone TZ, X is T, '
   118                                       'T name TN')[0]
   123                                       'T name TN')[0]
   119             self.assertEqual(cnx.entity_from_eid(eid).cw_etype, etname)
   124             self.assertEqual(cnx.entity_from_eid(eid).cw_etype, etname)
   120 
   125 
   121     def test_drop_index(self):
   126     def test_index_not_dropped_by_init(self):
   122         with self.admin_access.repo_cnx() as cnx:
   127         with self.admin_access.repo_cnx() as cnx:
   123             store = MassiveObjectStore(cnx)
   128             store = MassiveObjectStore(cnx)  # noqa
   124             cnx.commit()
   129             cnx.commit()
   125         with self.admin_access.repo_cnx() as cnx:
   130             indexes = all_indexes(cnx)
   126             crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
   131             self.assertIn('entities_pkey', indexes)
   127             indexes = [r[0] for r in crs.fetchall()]
   132             self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   128         self.assertNotIn('entities_pkey', indexes)
   133                           indexes)
   129         self.assertNotIn('owned_by_relation_pkey', indexes)
   134             self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   130         self.assertNotIn('owned_by_relation_to_idx', indexes)
   135                           indexes)
   131 
   136 
   132     def test_drop_index_recreation(self):
   137     def test_drop_index_recreation(self):
   133         with self.admin_access.repo_cnx() as cnx:
   138         with self.admin_access.repo_cnx() as cnx:
   134             store = MassiveObjectStore(cnx)
   139             store = MassiveObjectStore(cnx)
   135             store.finish()
   140 
   136             cnx.commit()
   141             store._drop_constraints()
   137         with self.admin_access.repo_cnx() as cnx:
   142             indexes = all_indexes(cnx)
   138             crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
   143             self.assertNotIn('entities_pkey', indexes)
   139             indexes = [r[0] for r in crs.fetchall()]
   144             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   140         self.assertIn('entities_pkey', indexes)
   145                              indexes)
   141         self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   146             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   142                       indexes)
   147                              indexes)
   143         self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   148 
   144                       indexes)
   149             store.finish()
       
   150             indexes = all_indexes(cnx)
       
   151             self.assertIn('entities_pkey', indexes)
       
   152             self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
       
   153                           indexes)
       
   154             self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
       
   155                           indexes)
   145 
   156 
   146     def test_eids_seq_range(self):
   157     def test_eids_seq_range(self):
   147         with self.admin_access.repo_cnx() as cnx:
   158         with self.admin_access.repo_cnx() as cnx:
   148             store = MassiveObjectStore(cnx, eids_seq_range=1000)
   159             store = MassiveObjectStore(cnx, eids_seq_range=1000)
   149             store.restart_eid_sequence(50000)
   160             store.restart_eid_sequence(50000)
   210             store.prepare_insert_entity('Location', nm='toto')
   221             store.prepare_insert_entity('Location', nm='toto')
   211             store.commit()  # commit modification to the database before flush
   222             store.commit()  # commit modification to the database before flush
   212             store.flush()
   223             store.flush()
   213         self.assertEqual(next(counter), 1)
   224         self.assertEqual(next(counter), 1)
   214 
   225 
   215     def test_slave_mode_indexes(self):
       
   216         with self.admin_access.repo_cnx() as cnx:
       
   217             slave_store = MassiveObjectStore(cnx, slave_mode=True)
       
   218         with self.admin_access.repo_cnx() as cnx:
       
   219             crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
       
   220             indexes = [r[0] for r in crs.fetchall()]
       
   221         self.assertIn('entities_pkey', indexes)
       
   222         self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
       
   223                       indexes)
       
   224         self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
       
   225                       indexes)
       
   226 
       
   227     def test_slave_mode_exception(self):
   226     def test_slave_mode_exception(self):
   228         with self.admin_access.repo_cnx() as cnx:
   227         with self.admin_access.repo_cnx() as cnx:
   229             slave_store = MassiveObjectStore(cnx, slave_mode=True)
   228             slave_store = MassiveObjectStore(cnx, slave_mode=True)
   230             self.assertRaises(RuntimeError, slave_store.finish)
   229             self.assertRaises(RuntimeError, slave_store.finish)
   231 
   230 
   247             store = MassiveObjectStore(cnx)
   246             store = MassiveObjectStore(cnx)
   248             self.push_geonames_data(self.datapath('geonames.csv'), store)
   247             self.push_geonames_data(self.datapath('geonames.csv'), store)
   249             store.flush()
   248             store.flush()
   250 
   249 
   251             # Check index
   250             # Check index
   252             crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
   251             indexes = all_indexes(cnx)
   253             indexes = [r[0] for r in crs.fetchall()]
       
   254             self.assertNotIn('entities_pkey', indexes)
   252             self.assertNotIn('entities_pkey', indexes)
   255             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   253             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   256                              indexes)
   254                              indexes)
   257             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   255             self.assertNotIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   258                              indexes)
   256                              indexes)
   259 
   257 
   260             # Cleanup -> index
   258             # Cleanup -> index
   261             store.finish()
   259             store.finish()
   262 
   260 
   263             # Check index again
   261             # Check index again
   264             crs = cnx.system_sql('SELECT indexname FROM pg_indexes')
   262             indexes = all_indexes(cnx)
   265             indexes = [r[0] for r in crs.fetchall()]
       
   266             self.assertIn('entities_pkey', indexes)
   263             self.assertIn('entities_pkey', indexes)
   267             self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   264             self.assertIn(build_index_name('owned_by_relation', ['eid_from', 'eid_to'], 'key_'),
   268                           indexes)
   265                           indexes)
   269             self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   266             self.assertIn(build_index_name('owned_by_relation', ['eid_from'], 'idx_'),
   270                           indexes)
   267                           indexes)