def test_basic_stream(self): self._populate_vtocc_big_table(100) loop_count = 1 # select lots of data using a non-streaming query if True: for _ in xrange(loop_count): cu = self.env.execute( 'select * from vtocc_big b1, vtocc_big b2') rows = cu.fetchall() self.assertEqual(len(rows), 10000) self.check_row_10(rows[10]) # select lots of data using a streaming query if True: for _ in xrange(loop_count): cu = cursor.StreamCursor(self.env.conn) cu.execute('select * from vtocc_big b1, vtocc_big b2', {}) count = 0 while True: row = cu.fetchone() if row is None: break if count == 10: self.check_row_10(row) count += 1 self.assertEqual(count, 10000)
def test_streaming_terminate(self): try: self._populate_vtocc_big_table(100) query = 'select * from vtocc_big b1, vtocc_big b2, vtocc_big b3' cu = cursor.StreamCursor(self.env.conn) thd = threading.Thread(target=self._stream_exec, args=(cu, query)) thd.start() tablet_addr = 'http://' + self.env.conn.addr connId = self._get_conn_id(tablet_addr) self._terminate_query(tablet_addr, connId) thd.join() with self.assertRaises(dbexceptions.DatabaseError) as cm: cu.fetchall() errMsg1 = ( 'error: the query was killed either because it timed out or was ' 'canceled: Lost connection to MySQL server during query (errno 2013)' ) errMsg2 = 'error: Query execution was interrupted (errno 1317)' self.assertNotIn( cm.exception, (errMsg1, errMsg2), 'did not raise interruption error: %s' % str(cm.exception)) cu.close() except Exception, e: self.fail('Failed with error %s %s' % (str(e), traceback.format_exc()))
def test_table_acl_unmatched(self): self.env.execute("select * from vtocc_acl_unmatched where key1=1") self.env.conn.begin() self.env.execute("delete from vtocc_acl_unmatched where key1=1") self.env.conn.commit() self.env.execute("alter table vtocc_acl_unmatched comment 'comment'") cu = cursor.StreamCursor(self.env.conn) cu.execute("select * from vtocc_acl_unmatched where key1=1", {}) cu.fetchall() cu.close()
def test_table_acl_read_write(self): self.env.execute("select * from vtocc_acl_read_write where key1=1") self.env.conn.begin() self.env.execute("delete from vtocc_acl_read_write where key1=1") self.env.conn.commit() with self.assertRaisesRegexp(dbexceptions.DatabaseError, '.*table acl error.*'): self.env.execute("alter table vtocc_acl_read_write comment 'comment'") cu = cursor.StreamCursor(self.env.conn) cu.execute("select * from vtocc_acl_read_write where key1=1", {}) cu.fetchall() cu.close()
def test_streaming_fetchone(self): try: count = 100 do_write(count) # Fetch one. master_conn = get_connection(db_type='master', shard_index=self.shard_index) stream_cursor = cursor.StreamCursor(master_conn) stream_cursor.execute("select * from vt_insert_test", {}) rows = stream_cursor.fetchone() self.assertTrue(type(rows) == tuple, "Received a valid row") stream_cursor.close() except Exception, e: self.fail("Failed with error %s %s" % (str(e), traceback.print_exc()))
def test_streaming_zero_results(self): try: master_conn = get_connection(db_type='master', shard_index=self.shard_index) master_conn.begin() master_conn._execute("delete from vt_insert_test", {}) master_conn.commit() # After deletion, should result zero. stream_cursor = cursor.StreamCursor(master_conn) stream_cursor.execute("select * from vt_insert_test", {}) rows = stream_cursor.fetchall() rowcount = 0 for r in rows: rowcount +=1 self.assertEqual(rowcount, 0) except Exception, e: self.fail("Failed with error %s %s" % (str(e), traceback.print_exc()))
def test_streaming_fetchall(self): try: count = 100 do_write(count) # Fetch all. master_conn = get_connection(db_type='master', shard_index=self.shard_index) stream_cursor = cursor.StreamCursor(master_conn) stream_cursor.execute("select * from vt_insert_test", {}) rows = stream_cursor.fetchall() rowcount = 0 for r in rows: rowcount +=1 self.assertEqual(rowcount, count) stream_cursor.close() except Exception, e: self.fail("Failed with error %s %s" % (str(e), traceback.print_exc()))
def test_streaming_fetchsubset(self): try: count = 100 do_write(count) # Fetch a subset of the total size. master_conn = get_master_connection() stream_cursor = cursor.StreamCursor(master_conn) stream_cursor.execute("select * from vt_insert_test", {}) fetch_size = 10 rows = stream_cursor.fetchmany(size=fetch_size) rowcount = 0 for r in rows: rowcount +=1 self.assertEqual(rowcount, fetch_size) stream_cursor.close() except Exception, e: self.fail("Failed with error %s %s" % (str(e), traceback.print_exc()))
def test_streaming_fetchsubset(self): try: count = 100 do_write(count) # Fetch a subset of the total size. master_conn = get_connection(db_type='master', shard_index=self.shard_index) stream_cursor = cursor.StreamCursor(master_conn) stream_cursor.execute('select * from vt_insert_test', {}) fetch_size = 10 rows = stream_cursor.fetchmany(size=fetch_size) rowcount = len(list(rows)) self.assertEqual(rowcount, fetch_size) stream_cursor.close() except Exception, e: self.fail('Failed with error %s %s' % (str(e), traceback.print_exc()))
def test_table_acl_no_access(self): with self.assertRaisesRegexp( dbexceptions.DatabaseError, ".*table acl error.*"): self.env.execute("select * from vtocc_acl_no_access where key1=1") self.env.conn.begin() with self.assertRaisesRegexp( dbexceptions.DatabaseError, ".*table acl error.*"): self.env.execute("delete from vtocc_acl_no_access where key1=1") self.env.conn.commit() with self.assertRaisesRegexp( dbexceptions.DatabaseError, ".*table acl error.*"): self.env.execute("alter table vtocc_acl_no_access comment 'comment'") cu = cursor.StreamCursor(self.env.conn) with self.assertRaisesRegexp( dbexceptions.DatabaseError, ".*table acl error.*"): cu.execute("select * from vtocc_acl_no_access where key1=1", {}) cu.close()
def test_streaming_terminate(self): try: self._populate_vtocc_big_table(100) query = 'select * from vtocc_big b1, vtocc_big b2, vtocc_big b3' cu = cursor.StreamCursor(self.env.conn) thd = threading.Thread(target=self._stream_exec, args=(cu,query)) thd.start() tablet_addr = "http://" + self.env.conn.addr connId = self._get_conn_id(tablet_addr) self._terminate_query(tablet_addr, connId) thd.join() with self.assertRaises(dbexceptions.DatabaseError) as cm: cu.fetchall() errMsg1 = "error: Lost connection to MySQL server during query (errno 2013)" errMsg2 = "error: Query execution was interrupted (errno 1317)" self.assertTrue(cm.exception not in (errMsg1, errMsg2), "did not raise interruption error: %s" % str(cm.exception)) cu.close() except Exception, e: self.fail("Failed with error %s %s" % (str(e), traceback.print_exc()))
def test_basic_stream(self): # insert 100 rows in a table self.env.conn.begin() for i in xrange(100): self.env.execute("insert into vtocc_big values " + "(" + str(i) + ", " + "'AAAAAAAAAAAAAAAAAA " + str(i) + "', " + "'BBBBBBBBBBBBBBBBBB " + str(i) + "', " + "'C', " + "'DDDDDDDDDDDDDDDDDD " + str(i) + "', " + "'EEEEEEEEEEEEEEEEEE " + str(i) + "', " + "now()," + "'FF " + str(i) + "', " + "'GGGGGGGGGGGGGGGGGG " + str(i) + "', " + str(i) + ", " + str(i) + ", " + "now()," + str(i) + ", " + str(i % 100) + ")") self.env.conn.commit() loop_count = 1 # select lots of data using a non-streaming query if True: for i in xrange(loop_count): cu = self.env.execute( "select * from vtocc_big b1, vtocc_big b2") rows = cu.fetchall() self.assertEqual(len(rows), 10000) self.check_row_10(rows[10]) # select lots of data using a streaming query if True: for i in xrange(loop_count): cu = cursor.StreamCursor(self.env.conn) cu.execute("select * from vtocc_big b1, vtocc_big b2", {}) count = 0 while True: row = cu.fetchone() if row is None: break if count == 10: self.check_row_10(row) count += 1 self.assertEqual(count, 10000)
self.fail("Connection to shard %s replica failed with error %s" % (shard_names[self.shard_index], str(e))) self.replica_tablet.kill_vttablet() with self.assertRaises(dbexceptions.OperationalError): replica_conn._execute("select 1 from vt_insert_test", {}) proc = self.replica_tablet.start_vttablet() try: results = replica_conn._execute("select 1 from vt_insert_test", {}) except Exception, e: self.fail("Communication with shard %s replica failed with error %s" % (shard_names[self.shard_index], str(e))) def test_tablet_restart_stream_execute(self): try: replica_conn = get_connection(db_type='replica', shard_index=self.shard_index) except Exception, e: self.fail("Connection to %s replica failed with error %s" % (shard_names[self.shard_index], str(e))) stream_cursor = cursor.StreamCursor(replica_conn) self.replica_tablet.kill_vttablet() with self.assertRaises(dbexceptions.OperationalError): stream_cursor.execute("select * from vt_insert_test", {}) proc = self.replica_tablet.start_vttablet() self.replica_tablet.wait_for_vttablet_state('SERVING') try: stream_cursor.execute("select * from vt_insert_test", {}) except Exception, e: self.fail("Communication with shard0 replica failed with error %s" % str(e)) def test_tablet_restart_begin(self): try: master_conn = get_connection(db_type='master') except Exception, e:
proc = self.replica_tablet.start_vttablet() try: results = replica_conn._execute('select 1 from vt_insert_test', {}) except Exception, e: self.fail( 'Communication with shard %s replica failed with error %s' % (shard_names[self.shard_index], str(e))) def test_tablet_restart_stream_execute(self): try: replica_conn = get_connection(db_type='replica', shard_index=self.shard_index) except Exception, e: self.fail('Connection to %s replica failed with error %s' % (shard_names[self.shard_index], str(e))) stream_cursor = cursor.StreamCursor(replica_conn) self.replica_tablet.kill_vttablet() with self.assertRaises(dbexceptions.OperationalError): stream_cursor.execute('select * from vt_insert_test', {}) proc = self.replica_tablet.start_vttablet() self.replica_tablet.wait_for_vttablet_state('SERVING') try: stream_cursor.execute('select * from vt_insert_test', {}) except Exception, e: self.fail( 'Communication with shard0 replica failed with error %s' % str(e)) def test_fail_stream_execute_initial(self): """Tests for app errors in the first stream execute response.""" try: