Merge branch 'mysql-8.0' into mysql-trunk

Change-Id: I4b977d47cc61de07ee184cd1277eb950674bdd35

Author: Ole John Aske

mysql-test/suite/ndb_tls/large_txn_non_mt.cnf

@@ -0,0 +1,10 @@
+!include suite/ndb/t/large_txn_non_mt.cnf
+
+[cluster_config.ndbd.1.1]
+RequireTls=true
+
+[cluster_config.ndbd.2.1]
+RequireTls=true
+
+[mysql_cluster]
+ndb-tls-search-path=$MYSQLTEST_VARDIR/std_data/ndb-tls/active

mysql-test/suite/ndb_tls/large_txn_non_mt.result

@@ -0,0 +1,85 @@
+create table t1 (a int primary key) engine=ndb;
+create table t2 (a int primary key) engine=ndb;
+create procedure do_insert(count int)
+begin
+set @x = 0;
+repeat
+insert into t1 values
+(@x+0),  (@x+1),  (@x+2),  (@x+3),
+(@x+4),  (@x+5),  (@x+6),  (@x+7),
+(@x+8),  (@x+9),  (@x+10), (@x+11),
+(@x+12), (@x+13), (@x+14), (@x+15),
+(@x+16), (@x+17), (@x+18), (@x+19),
+(@x+20), (@x+21), (@x+22), (@x+23),
+(@x+24), (@x+25), (@x+26), (@x+27),
+(@x+28), (@x+29), (@x+30), (@x+31);
+set @x = @x + 32;
+until @x >= count
+end repeat;
+end %
+begin;
+call do_insert(500000);
+rollback;
+begin;
+call do_insert(500000);
+commit;
+begin;
+insert into t2 select * from t1;
+rollback;
+begin;
+insert into t2 select * from t1;
+commit;
+begin;
+delete from t2;
+commit;
+begin;
+delete from t1;
+commit;
+drop procedure do_insert;
+drop table t1,t2;
+##############################
+#
+# Bug#34189965
+#   DbAcc Validate(WITH_DEBUG) of Unique Key locks has
+#   exponential overhead.
+#
+# In order to guarante read consistency when using an unique index,
+# shared read locks are set (and held) on the rows. When e.g. a
+# join query join in the *same* row multiple times, each access
+# results in additional locks being set. Such locks are all added
+# to the same 'parallel queue' the the ACC block, which can end up
+# with thousands of locks in the same parallel queue.
+#
+# When debug compiled, ACC validates the consistency of the queues,
+# iterating the entire queue. The overhead of that may become so
+# huge that the block thread scheduler starts complaining about
+# being 'struck in thread', 'oversleept' and 'sleeploop 10!'
+create table t (
+pk int primary key,
+uq int,
+i int,
+unique key (uq),
+key(i)
+) engine = ndbcluster;
+create table t100000 (
+i int
+) engine = ndbcluster;
+insert into t values
+(0,0,1), (1,1,1), (2,2,1), (3,3,1), (4,4,1),
+(5,5,1), (6,6,1), (7,7,1), (8,8,1), (9,9,1);
+insert into t100000
+select t1.i from
+t as t1
+straight_join t as t2 on t2.i=t1.i
+straight_join t as t3 on t3.i=t2.i
+straight_join t as t4 on t4.i=t3.i
+straight_join t as t5 on t5.i=t4.i;
+set ndb_join_pushdown=off;
+select /*+ BKA(t) */ count(*) from
+t100000 as t1
+straight_join t on t.uq=t1.i;
+count(*)
+100000
+set ndb_join_pushdown=default;
+drop table t;
+drop table t100000;

mysql-test/suite/ndb_tls/large_txn_non_mt.test

@@ -0,0 +1,3 @@
+--source suite/ndb_tls/include/check_openssl.inc
+--source suite/ndb/t/large_txn_non_mt.test
+

storage/ndb/src/common/transporter/TCP_Transporter.cpp

@@ -413,20 +413,14 @@ TCP_Transporter::doSend(bool need_wakeup)
       }
     }
 
-    if (Uint32(nBytesSent) == remain)  //Completed this send
+    if (likely(Uint32(nBytesSent) == remain))  //Completed this send
     {
       sum_sent += nBytesSent;
       assert(sum >= sum_sent);
       remain = sum - sum_sent;
       //g_eventLogger->info("Sent %d bytes on trp %u", nBytesSent, getTransporterIndex());
       break;
     }
-    else if (nBytesSent == TLS_BUSY_TRY_AGAIN)
-    {
-      // TLS is doing protocol layer stuff. We need to keep polling and
-      // trying to send until it is done.
-      return true;
-    }
     else if (nBytesSent > 0)           //Sent some, more pending
     {
       sum_sent += nBytesSent;
@@ -453,10 +447,16 @@ TCP_Transporter::doSend(bool need_wakeup)
         iov[pos].iov_base = ((char*)(iov[pos].iov_base))+nBytesSent;
       }
     }
-    else                               //Send failed, terminate
+    else                               //Send failed, handle or disconnect?
     {
       const int err = ndb_socket_errno();
 
+      if (nBytesSent == TLS_BUSY_TRY_AGAIN)
+      {
+        // In case TLS was 'BUSY' TransporterRegistry will send-retry later.
+        break;
+      }
+
 #if defined DEBUG_TRANSPORTER
       g_eventLogger->error("Send Failure(disconnect==%d) to node = %d "
                            "nBytesSent = %d "
@@ -584,7 +584,7 @@ TCP_Transporter::doReceive(TransporterReceiveHandle& recvdata)
 
       if(nBytesRead == TLS_BUSY_TRY_AGAIN) return TLS_BUSY_TRY_AGAIN;
 
-      if (nBytesRead > 0)
+      if (likely(nBytesRead > 0))
       {
         receiveBuffer.sizeOfData += nBytesRead;
         receiveBuffer.insertPtr  += nBytesRead;

storage/ndb/src/common/util/NdbSocket.cpp

@@ -188,7 +188,11 @@ static ssize_t handle_ssl_error(int err, const char * fn) {
       return 0;           // caller should close the socket
     case SSL_ERROR_WANT_READ:
     case SSL_ERROR_WANT_WRITE:
-      return TLS_BUSY_TRY_AGAIN;
+      // FIXME Bug#3569340:
+      //
+      // Note that for upper transporter layers we expect either 0 or -1
+      // to be returned in case of failures.
+      return TLS_BUSY_TRY_AGAIN;  // <- return -1;
     case SSL_ERROR_SYSCALL:
       return -1;          // caller should check errno and close the socket
     case SSL_ERROR_ZERO_RETURN: