def test_query_order_by_col_not_in_result__183(self):
test_collection_size = 8
test_collection_path = '/{0}/home/{1}/testcoln_for_col_not_in_result'.format(
self.sess.zone, self.sess.username)
c1 = c2 = None
try:
c1 = helpers.make_test_collection(self.sess,
test_collection_path + "1",
obj_count=test_collection_size)
c2 = helpers.make_test_collection(self.sess,
test_collection_path + "2",
obj_count=test_collection_size)
d12 = [
sorted([d.id for d in c.data_objects])
for c in sorted((c1, c2), key=lambda c: c.id)
]
query = self.sess.query(DataObject).filter(
Like(Collection.name,
test_collection_path + "_")).order_by(Collection.id)
q12 = list(map(lambda res: res[DataObject.id], query))
self.assertTrue(d12[0] +
d12[1] == sorted(q12[:test_collection_size]) +
sorted(q12[test_collection_size:]))
finally:
if c1: c1.remove(recurse=True, force=True)
if c2: c2.remove(recurse=True, force=True)
def test_query_data_name_and_id_no_columns(self):
'''Same test as above, but without providing query columns to parse results.
Result columns are retrieved by index 0..n
'''
# make a test collection larger than MAX_SQL_ROWS (number of files)
test_collection_size = 3*MAX_SQL_ROWS
test_collection_path = '/{0}/home/{1}/test_collection'.format(self.session.zone, self.session.username)
self.test_collection = helpers.make_test_collection(
self.session, test_collection_path, obj_count=test_collection_size)
# make specific query
sql = "select DATA_NAME, DATA_ID from R_DATA_MAIN join R_COLL_MAIN using (COLL_ID) where COLL_NAME = '{test_collection_path}'".format(**locals())
alias = 'list_data_name_id'
query = SpecificQuery(self.session, sql, alias)
# register query in iCAT
query.register()
# run query and check results
for i, result in enumerate(query):
self.assertIn('test', result[0])
self.assertIsNotNone(result[1])
self.assertEqual(i, test_collection_size - 1)
# unregister query
query.remove()
# remove test collection
self.test_collection.remove(recurse=True, force=True)
def test_query_data_name_and_id(self):
# make a test collection larger than MAX_SQL_ROWS (number of files)
test_collection_size = 3*MAX_SQL_ROWS
test_collection_path = '/{0}/home/{1}/test_collection'.format(self.session.zone, self.session.username)
self.test_collection = helpers.make_test_collection(
self.session, test_collection_path, obj_count=test_collection_size)
# make specific query
sql = "select DATA_NAME, DATA_ID from R_DATA_MAIN join R_COLL_MAIN using (COLL_ID) where COLL_NAME = '{test_collection_path}'".format(**locals())
alias = 'list_data_name_id'
columns = [DataObject.name, DataObject.id]
query = SpecificQuery(self.session, sql, alias, columns)
# register query in iCAT
query.register()
# run query and check results
for i, result in enumerate(query):
self.assertIn('test', result[DataObject.name])
self.assertIsNotNone(result[DataObject.id])
self.assertEqual(i, test_collection_size - 1)
# unregister query
query.remove()
# remove test collection
self.test_collection.remove(recurse=True, force=True)
def test_query_on_AVU_times(self):
test_collection_path = '/{zone}/home/{user}/test_collection'.format( zone = self.sess.zone, user = self.sess.username)
testColl = helpers.make_test_collection(self.sess, test_collection_path, obj_count = 1)
testData = testColl.data_objects[0]
testResc = self.sess.resources.get('demoResc')
testUser = self.sess.users.get(self.sess.username)
objects = { 'r': testResc, 'u': testUser, 'c':testColl, 'd':testData }
object_IDs = { sfx:obj.id for sfx,obj in objects.items() }
tables = { 'r': (Resource, ResourceMeta),
'u': (User, UserMeta),
'd': (DataObject, DataObjectMeta),
'c': (Collection, CollectionMeta) }
try:
str_number_incr = lambda str_numbers : str(1+max([0]+[int(n) if n.isdigit() else 0 for n in str_numbers]))
AVU_unique_incr = lambda obj,suffix='' : ( 'a_'+suffix,
'v_'+suffix,
str_number_incr(avu.units for avu in obj.metadata.items()) )
before = datetime.utcnow()
time.sleep(1.5)
for suffix,obj in objects.items(): obj.metadata.add( *AVU_unique_incr(obj,suffix) )
after = datetime.utcnow()
for suffix, tblpair in tables.items():
self.sess.query( *tblpair ).filter(tblpair[1].modify_time <= after )\
.filter(tblpair[1].modify_time > before )\
.filter(tblpair[0].id == object_IDs[suffix] ).one()
self.sess.query( *tblpair ).filter(tblpair[1].create_time <= after )\
.filter(tblpair[1].create_time > before )\
.filter(tblpair[0].id == object_IDs[suffix] ).one()
finally:
for obj in objects.values():
for avu in obj.metadata.items(): obj.metadata.remove(avu)
testColl.remove(recurse=True,force=True)
helpers.remove_unused_metadata( self.sess )
def test_query_data_name_and_id_no_columns(self):
'''Same test as above, but without providing query columns to parse results.
Result columns are retrieved by index 0..n
'''
# make a test collection larger than MAX_SQL_ROWS (number of files)
test_collection_size = 3*MAX_SQL_ROWS
test_collection_path = '/{0}/home/{1}/test_collection'.format(self.session.zone, self.session.username)
self.test_collection = helpers.make_test_collection(
self.session, test_collection_path, obj_count=test_collection_size)
# make specific query
sql = "select data_name, data_id from r_data_main join r_coll_main using (coll_id) where coll_name = '{test_collection_path}'".format(**locals())
alias = 'list_data_name_id'
query = SpecificQuery(self.session, sql, alias)
# register query in iCAT
query.register()
# run query and check results
for i, result in enumerate(query.get_results()):
self.assertIn('test', result[0])
self.assertIsNotNone(result[1])
self.assertEqual(i, test_collection_size - 1)
# unregister query
query.remove()
# remove test collection
self.test_collection.remove(recurse=True, force=True)
def test_query_data_name_and_id(self):
# make a test collection larger than MAX_SQL_ROWS (number of files)
test_collection_size = 3*MAX_SQL_ROWS
test_collection_path = '/{0}/home/{1}/test_collection'.format(self.session.zone, self.session.username)
self.test_collection = helpers.make_test_collection(
self.session, test_collection_path, obj_count=test_collection_size)
# make specific query
sql = "select data_name, data_id from r_data_main join r_coll_main using (coll_id) where coll_name = '{test_collection_path}'".format(**locals())
alias = 'list_data_name_id'
columns = [DataObject.name, DataObject.id]
query = SpecificQuery(self.session, sql, alias, columns)
# register query in iCAT
query.register()
# run query and check results
for i, result in enumerate(query.get_results()):
self.assertIn('test', result[DataObject.name])
self.assertIsNotNone(result[DataObject.id])
self.assertEqual(i, test_collection_size - 1)
# unregister query
query.remove()
# remove test collection
self.test_collection.remove(recurse=True, force=True)
def setUp(self):
self.sess = helpers.make_session()
# Create test collection
self.coll_path = '/{}/home/{}/test_dir'.format(self.sess.zone, self.sess.username)
self.obj_count = 2500
self.coll = helpers.make_test_collection(
self.sess, self.coll_path, self.obj_count)
def setUpClass(cls):
# once only (before all tests), set up large collection
print("Creating a large collection...", file=sys.stderr)
with helpers.make_session() as sess:
# Create test collection
cls.coll_path = '/{}/home/{}/test_dir'.format(
sess.zone, sess.username)
cls.obj_count = 2500
cls.coll = helpers.make_test_collection(sess, cls.coll_path,
cls.obj_count)
def __enter__(self): # - prepare for context block ("with" statement)
self.test_collection = helpers.make_test_collection( self.session, self.coll_path, obj_count=self.num_objects)
q_params = (Collection.name, DataObject.name)
if self.nAVUs > 0:
# - set the AVUs on the collection's objects:
for data_obj_path in map(lambda d:d[Collection.name]+"/"+d[DataObject.name],
self.session.query(*q_params).filter(Collection.name == self.test_collection.path)):
data_obj = self.session.data_objects.get(data_obj_path)
for key in (str(x) for x in py3_range(self.nAVUs)):
data_obj.metadata[key] = iRODSMeta(key, "1")
# - in subsequent test searches, match on each AVU of every data object in the collection:
q_params += (DataObjectMeta.name,)
# - The "with" statement receives, as context variable, a zero-arg function to build the query
return lambda : self.session.query( *q_params ).filter( Collection.name == self.test_collection.path)
def setUp(self):
self.sess = helpers.make_session_from_config()
# Create test collection
self.coll = helpers.make_test_collection(self.sess, self.coll_path,
self.obj_count)
def setUp(self):
self.sess = helpers.make_session_from_config()
# Create test collection
self.coll = helpers.make_test_collection(
self.sess, self.coll_path, self.obj_count)
