def test_null_types(self): """ Test to validate that the numpy protocol handler can deal with null values. @since 3.3.0 - updated 3.6.0: now numeric types used masked array @jira_ticket PYTHON-550 @expected_result Numpy can handle non mapped types' null values. @test_category data_types:serialization """ s = self.session s.client_protocol_handler = NumpyProtocolHandler table = "%s.%s" % (self.keyspace_name, self.function_table_name) create_table_with_all_types(table, s, 10) begin_unset = max( s.execute('select primkey from %s' % (table, ))[0]['primkey']) + 1 keys_null = range(begin_unset, begin_unset + 10) # scatter some emptry rows in here insert = "insert into %s (primkey) values (%%s)" % (table, ) execute_concurrent_with_args(s, insert, ((k, ) for k in keys_null)) result = s.execute("select * from %s" % (table, ))[0] from numpy.ma import masked, MaskedArray result_keys = result.pop('primkey') mapped_index = [v[1] for v in sorted(zip(result_keys, count()))] had_masked = had_none = False for col_array in result.values(): # these have to be different branches (as opposed to comparing against an 'unset value') # because None and `masked` have different identity and equals semantics if isinstance(col_array, MaskedArray): had_masked = True [ self.assertIsNot(col_array[i], masked) for i in mapped_index[:begin_unset] ] [ self.assertIs(col_array[i], masked) for i in mapped_index[begin_unset:] ] else: had_none = True [ self.assertIsNotNone(col_array[i]) for i in mapped_index[:begin_unset] ] [ self.assertIsNone(col_array[i]) for i in mapped_index[begin_unset:] ] self.assertTrue(had_masked) self.assertTrue(had_none)
def _insert(self, session, keyspace, count=12, consistency_level=ConsistencyLevel.ONE): session.execute('USE %s' % keyspace) ss = SimpleStatement('INSERT INTO cf(k, i) VALUES (0, 0)', consistency_level=consistency_level) tries = 0 while tries < 100: try: execute_concurrent_with_args(session, ss, [None] * count) return except (OperationTimedOut, WriteTimeout, WriteFailure): ex_type, ex, tb = sys.exc_info() log.warn("{0}: {1} Backtrace: {2}".format(ex_type.__name__, ex, traceback.extract_tb(tb))) del tb tries += 1 raise RuntimeError("Failed to execute query after 100 attempts: {0}".format(ss))
def execute_concurrent_args_helper(self, session, query, params): tries = 0 while tries < 100: try: return execute_concurrent_with_args(session, query, params, concurrency=50) except (ReadTimeout, WriteTimeout, OperationTimedOut, ReadFailure, WriteFailure): ex_type, ex, tb = sys.exc_info() log.warn("{0}: {1} Backtrace: {2}".format(ex_type.__name__, ex, traceback.extract_tb(tb))) del tb tries += 1 raise RuntimeError("Failed to execute query after 100 attempts: {0}".format(query))
def test_concurrent_with_paging(self): statements_and_params = zip(cycle(["INSERT INTO test3rf.test (k, v) VALUES (%s, 0)"]), [(i, ) for i in range(100)]) execute_concurrent(self.session, list(statements_and_params)) prepared = self.session.prepare("SELECT * FROM test3rf.test") for fetch_size in (2, 3, 7, 10, 99, 100, 101, 10000): self.session.default_fetch_size = fetch_size results = execute_concurrent_with_args(self.session, prepared, [None] * 10) self.assertEqual(10, len(results)) for (success, result) in results: self.assertTrue(success) self.assertEqual(100, len(list(result)))
def test_recursion_limited(self): """ Verify that recursion is controlled when raise_on_first_error=False and something is wrong with the query. PYTHON-585 """ max_recursion = sys.getrecursionlimit() s = Session(Cluster(), [Host("127.0.0.1", SimpleConvictionPolicy)]) self.assertRaises(TypeError, execute_concurrent_with_args, s, "doesn't matter", [('param',)] * max_recursion, raise_on_first_error=True) results = execute_concurrent_with_args(s, "doesn't matter", [('param',)] * max_recursion, raise_on_first_error=False) # previously self.assertEqual(len(results), max_recursion) for r in results: self.assertFalse(r[0]) self.assertIsInstance(r[1], TypeError)
def test_named_table_with_mv(self): """ Test NamedTable access to materialized views Creates some materialized views using Traditional CQL. Then ensures we can access those materialized view using the NamedKeyspace, and NamedTable interfaces. Tests basic filtering as well. @since 3.0.0 @jira_ticket PYTHON-406 @expected_result Named Tables should have access to materialized views @test_category materialized_view """ ks = models.DEFAULT_KEYSPACE self.session.execute( "DROP MATERIALIZED VIEW IF EXISTS {0}.alltimehigh".format(ks)) self.session.execute( "DROP MATERIALIZED VIEW IF EXISTS {0}.monthlyhigh".format(ks)) self.session.execute("DROP TABLE IF EXISTS {0}.scores".format(ks)) create_table = """CREATE TABLE {0}.scores( user TEXT, game TEXT, year INT, month INT, day INT, score INT, PRIMARY KEY (user, game, year, month, day) )""".format(ks) self.session.execute(create_table) create_mv = """CREATE MATERIALIZED VIEW {0}.monthlyhigh AS SELECT game, year, month, score, user, day FROM {0}.scores WHERE game IS NOT NULL AND year IS NOT NULL AND month IS NOT NULL AND score IS NOT NULL AND user IS NOT NULL AND day IS NOT NULL PRIMARY KEY ((game, year, month), score, user, day) WITH CLUSTERING ORDER BY (score DESC, user ASC, day ASC)""".format( ks) self.session.execute(create_mv) create_mv_alltime = """CREATE MATERIALIZED VIEW {0}.alltimehigh AS SELECT * FROM {0}.scores WHERE game IS NOT NULL AND score IS NOT NULL AND user IS NOT NULL AND year IS NOT NULL AND month IS NOT NULL AND day IS NOT NULL PRIMARY KEY (game, score, user, year, month, day) WITH CLUSTERING ORDER BY (score DESC)""".format(ks) self.session.execute(create_mv_alltime) # Populate the base table with data prepared_insert = self.session.prepare( """INSERT INTO {0}.scores (user, game, year, month, day, score) VALUES (?, ?, ? ,? ,?, ?)""" .format(ks)) parameters = (('pcmanus', 'Coup', 2015, 5, 1, 4000), ('jbellis', 'Coup', 2015, 5, 3, 1750), ('yukim', 'Coup', 2015, 5, 3, 2250), ('tjake', 'Coup', 2015, 5, 3, 500), ('iamaleksey', 'Coup', 2015, 6, 1, 2500), ('tjake', 'Coup', 2015, 6, 2, 1000), ('pcmanus', 'Coup', 2015, 6, 2, 2000), ('jmckenzie', 'Coup', 2015, 6, 9, 2700), ('jbellis', 'Coup', 2015, 6, 20, 3500), ('jbellis', 'Checkers', 2015, 6, 20, 1200), ('jbellis', 'Chess', 2015, 6, 21, 3500), ('pcmanus', 'Chess', 2015, 1, 25, 3200)) prepared_insert.consistency_level = ConsistencyLevel.ALL execute_concurrent_with_args(self.session, prepared_insert, parameters) # Attempt to query the data using Named Table interface # Also test filtering on mv's key_space = NamedKeyspace(ks) mv_monthly = key_space.table("monthlyhigh") mv_all_time = key_space.table("alltimehigh") self.assertTrue( self.check_table_size("scores", key_space, len(parameters))) self.assertTrue( self.check_table_size("monthlyhigh", key_space, len(parameters))) self.assertTrue( self.check_table_size("alltimehigh", key_space, len(parameters))) filtered_mv_monthly_objects = mv_monthly.objects.filter(game='Chess', year=2015, month=6) self.assertEqual(len(filtered_mv_monthly_objects), 1) self.assertEqual(filtered_mv_monthly_objects[0]['score'], 3500) self.assertEqual(filtered_mv_monthly_objects[0]['user'], 'jbellis') filtered_mv_alltime_objects = mv_all_time.objects.filter(game='Chess') self.assertEqual(len(filtered_mv_alltime_objects), 2) self.assertEqual(filtered_mv_alltime_objects[0]['score'], 3500)