MDEV-34 delete storage/ndb and sql/*ndb* (and collateral changes)

remove:
* NDB from everywhere
* IM from mtr-v1
* packaging/rpm-oel and packaging/rpm-uln
* few unused spec files
* plug.in file
* .bzrignore

12 files changed, 8 insertions, 1957 deletions

diff --git a/BUILD/SETUP.sh b/BUILD/SETUP.sh
index 860560767a7..a0fddfb2413 100755
--- a/BUILD/SETUP.sh
+++ b/BUILD/SETUP.sh
@@ -205,9 +205,8 @@ fi
 
 max_no_embedded_configs="$SSL_LIBRARY --with-plugins=max"
 max_no_qc_configs="$SSL_LIBRARY --with-plugins=max --without-query-cache"
-max_no_ndb_configs="$SSL_LIBRARY --with-plugins=max-no-ndb --with-embedded-server --with-libevent"
 max_configs="$SSL_LIBRARY --with-plugins=max --with-embedded-server --with-libevent"
-all_configs="$SSL_LIBRARY --with-plugins=max --with-plugin-ndbcluster --with-embedded-server --with-innodb_plugin --with-libevent"
+all_configs="$SSL_LIBRARY --with-plugins=max --with-embedded-server --with-innodb_plugin --with-libevent"
 
 #
 # CPU and platform specific compilation flags.
diff --git a/BUILD/build_mccge.sh b/BUILD/build_mccge.sh
deleted file mode 100755
index 78e5350dc1b..00000000000
--- a/BUILD/build_mccge.sh
+++ /dev/null
@@ -1,1876 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2008, 2010, Oracle.
-# Copyright (c) 2009-2011 Monty Program Ab
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; version 2
-# of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Library General Public License for more details.
-#
-# You should have received a copy of the GNU Library General Public
-# License along with this library; if not, write to the Free
-# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
-# MA 02110-1301, USA
-
-die()
-{
-  echo "ERROR: $@"; exit 1;
-}
-
-get_key_value()
-{
-  echo "$1" | sed 's/^--[a-zA-Z_-]*=//'
-}
-
-developer_usage()
-{
-cat <<EOF
-  This script can be used by developers of MariaDB wanting to try out
-  early versions before binary versions are available, anyone needing
-  a version with a special patch included that needs to be built from
-  source code, or anyone else wanting to exercise full control over
-  the build process.
-
-  This help text is targeted towards those that want to debug and test
-  source code releases. If you have downloaded a source code release
-  and simply want to build a usable binary, you should read the
-  --sysadmin-help instead.
-
-  Three environment variables can be used to define the default behaviour:
-
-  MYSQL_DEVELOPER
-    Defining this variable is similar to setting the --developer flag
-  MYSQL_DEVELOPER_PACKAGE=package
-    Defining this variable is similar to setting the --package=* 
-    variable
-  MYSQL_DEVELOPER_DEBUG
-    Defining this variable sets the --with-debug flag
-
-  Options used with this script always override any default behaviour. 
-
-  More information for developers can be found in --help, 
-  --sysadmin-help, and --extended-help.
-
-  The most common usage for developers is to set the three variables 
-  mentioned previously and then simply to run the script without any 
-  additional parameters, using them only when needing to change some 
-  things like not requiring debug build. If some of these environment 
-  variables have already been set, you can use the corresponding options 
-  to unset them and reverse their effects.
-EOF
-}
-
-sysadmin_usage()
-{
-cat <<EOF
-
-  It is assumed that you are building on a computer which is of the 
-  same type as that on which you intend to run the program.
-
-  The simplest possible way to run this script is to allow it to use the 
-  built-in defaults everywhere, invoking it simply as (from top-level
-  MariaDB source directory):
-
-  shell> BUILD/build_mccge.sh
-
-  This performs the following operations:
-    1) Detects the operating system. Currently, Linux, FreeBSD, Solaris 
-      8/9/10/11, and Mac OS X are supported by this script.
-    2) Detect the type of CPU being used. Currently supported processors 
-      are: x86 for all supported operating systems, Itanium for Linux 
-      with GCC, and x86 + SPARC for Solaris using the Forte compiler and
-      finally x86 on Linux using the Intel compiler.
-    3) Invokes the GCC compiler.
-    4) Builds a set of of binaries ; for more information about these,
-       see --extended-help.
-    5) Default compiler is always gcc.
-  
-  The default version assumes that you have a source code tarball from 
-  which you are building, and thus autoconf and automake do not need to 
-  be run. If you have downloaded a launchpad tree then you should read 
-  --developer-help.
-
-  If your building on a Solaris SPARC machine and you want to compile
-  using SunStudio you must set 
-  --compiler=forte; if you want to build using the Intel compiler on 
-  Linux, you need to set --compiler=icc. If you want to use the AMD
-  compiler Open64 set --compiler=open64.
-
-  A synonym for forte is SunStudio, so one can also use
-  --compiler=SunStudio.
-
-  If you want to make sure that a 64-bit version is built then you 
-  should add the flag --64. This is always set on Solaris machines and 
-  when check-cpu is able to discover that a 64-bit CPU is being used. If 
-  you want to ensure that a 32-bit binary is produced, use --32 instead.
-
-  If you need the binaries to be installed in a different location from 
-  /usr/local/mysql, then you should set --prefix to point to where you
-  want the binaries installed.
-
-  Using a data directory other than the default (PREFIX/data) can be 
-  done when starting the server, or by invoking this script with 
-  the --datadir option.
-
-  If you want your binaries stripped of surplus debug or other 
-  information, use the --strip option.
-
-  If you want debug information in the binary (for example, to be
-  able to send gdb core dumps to support), then you should add the 
-  flag --with-debug; if you want a production build with only debugging 
-  information in the binary then use --debug.
-EOF
-}
-
-usage()
-{
-cat <<EOF
-
-Usage: $0 [options]
-  --help                  Show this help message.
-  --sysadmin-help         Show help for system administrators wishing 
-                          to build MariaDB
-  --developer-help        Show help for developers trying to build MariaDB
-  --with-help             Show extended help on --with-xxx options to 
-                          configure
-  --extended-help         Show extended help message
-  --without-debug         Build non-debug version
-  --use-comment           Set the comment in the build
-  --with-fast-mutexes     Use try/retry method of acquiring mutex
-  --without-fast-mutexes  Don't use try/retry method of acquiring mutex
-  --without-perfschema    Don't build with performance schema
-  --generate-feedback path Compile with feedback using the specified directory
-                          to store the feedback files
-  --use-feedback path     Compile using feedback information from the specified
-                          directory
-  --with-debug            Build debug version
-  --extra-debug-flag flag Add -Dflag to compiler flags
-                          InnoDB supports the following debug flags,
-                          UNIV_DEBUG, UNIV_SYNC_DEBUG, UNIV_MEM_DEBUG,
-                          UNIV_DEBUG_THREAD_CREATION, UNIV_DEBUG_LOCK_VALIDATE,
-                          UNIV_DEBUG_PRINT, UNIV_DEBUG_FILE_ACCESS,
-                          UNIV_LIGHT_MEM_DEBUG, UNIV_LOG_DEBUG,
-                          UNIV_IBUF_COUNT_DEBUG, UNIV_SEARCH_DEBUG,
-                          UNIV_LOG_LSN_DEBUG, UNIV_ZIP_DEBUG, UNIV_AHI_DEBUG,
-                          UNIV_DEBUG_VALGRIND, UNIV_SQL_DEBUG, UNIV_AIO_DEBUG,
-                          UNIV_BTR_DEBUG, UNIV_LRU_DEBUG, UNIV_BUF_DEBUG,
-                          UNIV_HASH_DEBUG, UNIV_LIST_DEBUG, UNIV_IBUF_DEBUG
-  --with-link-time-optimizer
-                          Link time optimizations enabled (Requires GCC 4.5
-                          if GCC used), available for icc as well. This flag
-                          is only considered if also fast is set.
-  --with-mso              Special flag used by Open64 compiler (requres at
-                          least version 4.2.3) that enables optimisations
-                          for multi-core scalability.
-  --configure-only        Stop after running configure.
-  --print-only            Print commands that the script will execute, 
-                          but do not actually execute
-  --prefix=path           Build with prefix 'path'
-  --datadir=path          Build with data directory set to non-standard 
-                          'path'
-  --debug                 Build normal version, but add debug 
-                          information to binary
-  --developer             Use extensions that most MariaDB developers use
-  --no-developer          Do not use extensions that most developers of 
-                          MariaDB use
-  --compiler=[gcc|icc|forte|SunStudio|open64] Select compiler
-  --cpu=[x86|x86_64|sparc|itanium]            Select CPU type
-                          x86 => x86 and 32-bit binary
-                          x86_64 => x86 and 64 bit binary
-  --warning-mode=[extra|pedantic|normal|no]   Set warning mode level
-  --warnings              Set warning mode to normal
-  --32                    Build a 32-bit binary even if CPU is 64-bit
-  --64                    Build a 64-bit binary even if not sure a
-                          64-bit CPU is being used
-  --package=[pro|classic] Select package to build
-  --parallelism=number    Define parallelism in make
-  --strip                 Strip binaries
-  --error-inject          Enable error injection into MariaDB Server and 
-                          data nodes
-  --valgrind              Build with valgrind
-  --fast                  Optimise for CPU architecture built on
-  --static-linking        Statically link system libraries into binaries
-  --use-tcmalloc          Link with tcmalloc instead of standard malloc (Linux only)
-  --with-flags *          Pass extra --with-xxx options to configure
-EOF
-  if test "x$1" != "x" ; then
-    echo "Failure Message: $1"
-  fi
-}
-
-extended_usage()
-{
-  cat <<EOF
-
-  Extended help text for this script:
-  ----------------------------------- 
-
-  This script is intended to make it easier to build
-  performance-optimised MariaDB versions from source on these
-  platforms/compilers: Linux/x86 (32-bit and 64-bit) (either using gcc
-  or icc), Linux Itanium, Solaris 8,9,10 and 11 x86 and SPARC using
-  gcc or SunStudio and MacOSX/x86/gcc.
-
-  The script automatically detects CPU type and operating system; The
-  default compiler is always gcc.
-
-  To build on other platforms you can use the --print-only option on a
-  supported platform and edit the output for a proper set of commands on
-  the specific platform you are using.
-
-  Using the --package option, it is also possible to build a "classic"
-  version of MariaDB having only the MyISAM storage engine, a "Pro"
-  package including all storage engines and other features except MariaDB
-  Cluster, and an "extended" package including these features plus MariaDB
-  Cluster (this is the default if the --developer option is used).
-
-  Different MariaDB storage engines are included in the build, depending
-  on which --package option is used. The comment and version strong
-  suffix are also set according to the package selected.
-
-  --package=pro
-    storage engines:
-      ARCHIVE, BLACKHOLE, CSV, FEDERATED, INNODB, MYISAM
-      (All storage engines except NDB)
-    comment: Pro versions
-    version string suffix: [none]
-
-  --package=classic
-    storage engines: CSV, MYISAM
-    comment: Version without InnoDB and Maria
-    version string suffix: [none]
-
-  All packages except Classic include support for user-defined
-  partitioning. All packages include support for Performance
-  Schema.
-
-  If --with-debug is used, an additional "-debug" is appended to the
-  version string.
-
-  --with-debug[=full]
-    This option will ensure that the version is built with debug
-    information enabled; the optimisation level is decreased to -O.
-
-  --developer
-    This option changes a number of things to make the version built
-    more appropriate to the debugging and testing needs of developers. 
-    It changes the default package to "extended". It also changes the 
-    default warning mode from "none" to "normal", which allows an 
-    extensive list of warnings to be generated.
-
-  --error-inject
-    This flag is used only when the --developer option is also used, and
-    enables error injection in both the MySQL Server and in MySQL
-    Cluster data nodes.
-
-  The following is a list of the default configure options used for all
-  packages:
-
-  --prefix: /usr/local/mysql (can be overridden)
-
-  --libexecdir: <prefix>/bin (can be overridden)
-
-  --localstatedir: <prefix>/data, unless --datadir is used, in which
-    case it defaults to <datadir>/data (can be overridden by setting
-    --localstatedir explicitly).
-
-  --enable-local-infile: Enable use of the LOAD DATA FROM  LOCAL INFILE
-    command (cannot be overridden).
-
-  --enable-thread-safe-client: Enable the multi-threaded mysql client
-    library (cannot be overridden).
-
-  --with-big-tables: Enable use of tables with more than 4G rows (cannot
-    be overridden).
-
-  --with-extra-charsets=all: Enable use of all character sets supported
-    by MySQL (cannot be overridden).
-
-  --with-ssl: Enable use of yaSSL library included in the MySQL source
-    if possible (GCC and same CC and CXX).
-    (cannot be overridden).
-
-  --with-pic: Build all binaries using position independent assembler
-    to avoid problems with dynamic linkers (cannot be overridden).
-
-  --without-example-engine: Ensure that the example engine isn't built,
-    it cannot do any useful things, it's merely intended as documentation.
-    (cannot be overridden)
-
-  --with-csv-storage-engine: Ensure that the CSV storage engine is
-    included in all builds. Since CSV is required for log tables in
-    MySQL 5.1, this option cannot be overridden.
-
-    (Note that MyISAM support is always built into the MySQL Server; the
-    server *cannot* be built without MyISAM.)
-
-  --with-mysqld-ldflags=-static
-  --with-client-ldflags=-static
-    Ensures that binaries for, respectively, the MySQL server and client
-    are built with static libraries except for the system libraries,
-    which use dynamically loaded libraries provided by the operating
-    system. Building with --developer sets these to all-static instead, 
-    to build everything statically.
-
-  In addition there are some configure options that are specific to
-  Linux operating systems:
-
-  --enable-assembler
-    Include assembler code optimisations for a number of mostly string
-    methods. Used for x86 processors only.
-
-  Neither of the preceding options can be disabled.
-
-  MySQL Cluster Carrier Grade edition also adds the following options
-  (also used by the extended package):
-
-  --with-ndbcluster
-    Include the NDB Cluster storage engine, its kernel, management
-    server, and client, as well as support for the NDB and MGM APIs.
-
-  --without-ndb-debug
-    Do not include specific NDB debug code, not even in debug versions
-    (cannot be overridden).
-
-  Package-specific options:
-  -------------------------
-  --with-innodb
-    Specifically included in the "pro" package.
-
-  --with-comment
-    Sets the comment for the MySQL version, by package, as described
-    above.
-
-  --with-server-suffix
-    Sets the server suffix on the MySQL version, by package, as
-    described above.
-
-  Other options used:
-  -------------------
-  --with-readline
-    Use the GPL readline library for command editing functions.
-
-  --with-libedit
-    Use the BSD licensed library for command editing functions.
-
-  --with-zlib-dir=bundled
-    Use the zlib package bundled with MySQL.
-
-  --with-mysqld-libs=-lmtmalloc
-    Used on Solaris to ensure that the proper malloc library is used.
-    Investigations have shown mtmalloc to be the best choice on Solaris,
-    also umem has good performance on Solaris but better debugging
-    capabilities.
-
-  Compiler options:
-  -----------------
-
-    This section describes the compiler options for each of the different
-    platforms supported by this script.
-
-    The --fast option adds -mtune=cpu_arg to the C/C++ flags (provides
-    support for Nocona, K8, and other processors), this option is valid
-    when gcc is the compiler.
-
-    Use of the --debug option adds -g to the C/C++ flags.
-
-    In all cases it is possible to override the definition of CC and CXX
-    by calling the script as follows:
-    CC="/usr/local/bin/gcc" CXX="/usr/local/bin/gcc" BUILD/build_mccge.sh
-
-  Feedback profiler on gcc
-  ------------------------
-  Using gcc --generate-feedback=path causes the following flags to be added
-  to the compiler flags.
-
-  --fprofile-generate
-  --fprofile-dir=path
-
-  Using gcc with --use-feedback=path causes the following flags to be added
-  to the compiler flags. --fprofile-correction indicates MySQL is a multi-
-  threaded application and thus counters can be inconsistent with each other
-  and the compiler should take this into account.
-
-  --fprofile-use
-  --fprofile-dir=path
-  --fprofile-correction
-
-  Feedback compilation using Open64
-  ---------------------------------
-
-  Using Open64 with --generate-feedback=path causes the following flags to
-  be added to the compiler flags.
-
-  -fb-create path/feedback
-
-  Using Open64 with --use-feedback=path causes the following flags to be
-  added to the compiler flags.
-
-  --fb-opt path/feedback
-
-  Linux/x86+Itanium/gcc
-  -------------
-    For debug builds -O is used and otherwise -O3 is used.Discovery of a
-    Nocona or Core 2 Duo CPU causes a 64-bit binary to be built;
-    otherwise, the binary is 32-bit. To build a 64-bit binary, -m64 is
-    added to the C/C++ flags. (To build a 32-bit binary on a 64-bit CPU,
-    use the --32 option as described previously.)
-
-    When gcc 4.5 is used and the user set --with-link-time-optimizer then
-    also --flto is added to compiler flags and linker flags.
-
-  Linux/x86+Itanium/icc
-  -------------
-    Flags used:
-    CC  = icc -static-libgcc -static-intel
-    C++ = icpc -static-libgcc -static-intel
-    C/C++ flags = -mp -restrict
-
-    On Itanium we also add -no-ftz and to CC and C++ flags.
-
-    Note that if the user of this script sets CC or CXX explicitly then
-    also -static-libgcc and -static-intel needs to be set in the CC and
-    CXX.
-
-    The non-debug versions also add the following:
-      C/C++ flags += -O3 unroll2 -ip
-
-    The fast version adds (if --with-link-time-optimizer is used):
-      C/C++ flags += -ipo
-
-    On discovery of a Core 2 Duo architecture while using icc, -xT is also 
-    added to the C/C++ flags; this provides optimisations specific to Core 
-    2 Duo. This is added only when the --fast flag is set.
-
-  Linux/x86/Open64
-  ----------------
-    For normal builds use -O3, when fast flag is set one also adds
-    --march=auto to generate optimized builds for the CPU used. If
-    --with-link-time-optimizer is set also -ipa is set. There is also
-    a special flag --with-mso which can be set to get --mso set which
-    activates optimisation for multi-core scalability.
-
-  FreeBSD/x86/gcc
-  ---------------
-    No flags are used. Instead, configure determines the proper flags to 
-    use.
-
-  Solaris/x86/gcc
-  ---------------
-    All builds on Solaris are by default 64-bit, so -m64 is always used in
-    the C/C++ flags. LDFLAGS is set to -m64 -O/-O2/-O3. If for
-    some reason a 32-bit Solaris is used it is necessary to add the flag
-    --32 to the script invocation. Due to bugs in compiling with -O3 on
-    Solaris only -O2 is used by default, when --fast flag is used -O3 will
-    be used instead.
-
-    Sets -m64 (default) or -m32 (if specifically set) in LDFLAGS and
-    C/C++ flags.
-
-  Solaris/Sparc/Forte
-  -------------------
-    Uses cc as CC and CC as CXX
-    Note that SunStudio uses different binaries for C and C++ compilers.
-
-    Set -m64 (default) or -m32 (if specifically set) in ASFLAGS,
-    LDFLAGS and C/C++ flags.
-
-    Sets ASFLAGS=LDFLAGS=compiler flags=xarch=sparc, so that we compile
-    Sparc v9 binaries, also -mt is set in all those since we're always
-    building a multithreaded program.
-
-    C flags   = -xstrconst    This flag is set only on SPARC
-    C++ flags = -noex
-
-    Set the following C/C++ flags:
-    -fsimple=1
-    -ftrap=%none
-    -nofstore          This flag is set only on x86
-    -xbuiltin=%all
-    -xlibmil
-    -xlibmopt
-
-    Set the C++ flag:
-    -noex
-    -features=no%except    This flag is set only on x86
-
-    When compiling with fast we set (-ipo only used if we have
-    set --with-link-time-optimizer):
-    C/C++ flags: -xtarget=native -xunroll=3 -xipo
-    LDFLAGS: -xipo
-
-    When not compiling with fast we always set -xtarget=generic
-
-    When compiling with fast on SPARC we also set:
-    C/C++ flags: -xbinopt=prepare
-    LDFLAGS: -xbinopt=prepare
-
-    When compiling with fast on x86 we also set:
-    C/C++ flags: -xregs=frameptr
-    When not compiling with fast we set on x86
-    C/C++ flags: -xregs=no%frameptr
-
-    On SPARC we set
-    ASFLAGS = LDFLAGS = C/C++ flags = -xarch=sparc
-
-    The optimisation level is
-    -xO         Debug builds
-    -xO2        Production build on SPARC
-    -xO3        Production build on x86
-    -xO4        Fast builds on SPARC/x86
-
-  MacOSX/x86/gcc
-  --------------
-    C/C++ flags include -fno-common -arch i386.
-    When 64-bits builds then i386 is replaced by x86_64.
-
-    Non-debug versions also add -Os -felide-constructors, where "-Os"
-    means the build is space-optimised as long as the space optimisations
-    do not negatively affect performance. Debug versions use -O.
-  
-    Mac OS X builds will always be 32-bit by default, when --64 is added
-    the build will be 64 bit instead. Thus the flag --m64 is added only
-    when specifically given as an option.
-EOF
-}
-
-with_usage()
-{
-  cat <<EOF
-
-  To obtain extended help on the --with-* options available, run this
-  script with --configure-only to create a configuration file. Then
-  issue the command ./configure --help to get an extensive list of
-  possible configure options.
-
-  The remainder of this text focuses on those options which are useful
-  in building binaries for MySQL Cluster Carrier Grade Edition.
-
-  --with-ndb-sci=/opt/DIS
-    Used to build a MySQL Cluster Carrier Grade Edition that can use the
-    SCI Transporter. The Dolphin SCI installation must be completed
-    first (see 
-    http://dev.mysql.com/doc/refman/5.1/en/mysql-cluster-interconnects.html
-    for more information).
-
-  --with-ndb-test
-    Compile the MySQL Cluster test programs.
-
-  --with-ndb-port=PORT
-    Change the default port for the MySQL Cluster management server.
-
-  --with-ndb-port-base=PORT
-    Change the default port base for MySQL Cluster data nodes.
-
-  --without-query-cache
-    Build the MySQL Server without the query cache, which is often not
-    of value in MySQL Cluster applications.
-
-  --with-atomic-ops=rwlocks|smp|up
-                          Implement atomic operations using pthread
-                          rwlocks or atomic CPU instructions for
-                          multi-processor (default) or single-processor
-                          configurations.
-
-  --without-geometry      Do not build geometry-related portions of the
-                          MySQL Server. Seldom used in MySQL Cluster
-                          applications.
-
-  --with-ndb-cc-flags=FLAGS
-    This option can be used to build MySQL Cluster with error injection
-    on the data nodes. It can be used to pass special options to
-    programs in the NDB kernel for special test builds.
-    The option for enabling data node error injection is -DERROR_INSERT.
-EOF
-}
-
-parse_package()
-{
-  case "$package" in
-    classic )
-      package="classic"
-      ;;
-    pro )
-      package="pro"
-      ;;
-    extended )
-      package="extended"
-      ;;
-    *)
-      echo "Unknown package '$package'"
-      exit 1
-      ;;
-  esac
-}
-
-parse_warning_mode()
-{
-  case "$warning_mode" in
-    pedantic )
-      warning_mode="pedantic"
-      ;;
-    extra_warnings | extra-warnings | extra )
-      warning_mode="extra"
-      ;;
-    no )
-      warning_mode=
-      ;;
-    normal )
-      warning_mode="normal"
-      ;;
-    *)
-      echo "Unknown warning mode '$warning_mode'"
-      exit 1
-      ;;
-  esac
-}
-
-#
-# We currently only support x86, Itanium and UltraSparc processors.
-#
-parse_cpu_type()
-{
-  case "$cpu_type" in
-    x86 )
-      cpu_type="x86"
-      if test "x$m64" = "x" ; then
-        m64="no"
-      fi
-      ;;
-    x86_64 )
-      cpu_type="x86"
-      if test "x$m64" = "x" ; then
-        m64="yes"
-      fi
-      ;;
-    itanium )
-      cpu_type="itanium"
-      ;;
-    sparc )
-      cpu_type="sparc"
-      ;;
-    * )
-      echo "Unknown CPU type $cpu_type"
-      exit 1
-      ;;
-  esac
-  return
-}
-
-#
-# We currently only support gcc, icc and Forte.
-#
-parse_compiler()
-{
-  case "$compiler" in
-    gcc )
-      compiler="gcc"
-      ;;
-    icc )
-      compiler="icc"
-      ;;
-    forte | SunStudio | sunstudio )
-      compiler="forte"
-      ;;
-    open64 | Open64 )
-      compiler="open64"
-      ;;
-    *)
-      echo "Unknown compiler '$compiler'"
-      exit 1
-      ;;
-  esac
-}
-
-parse_options()
-{
-  while test $# -gt 0
-  do
-    case "$1" in
-    --prefix=*)
-      prefix=`get_key_value "$1"`
-      ;;
-    --datadir=*)
-      datadir=`get_key_value "$1"`
-      ;;
-    --with-link-time-optimizer)
-      with_link_time_optimizer="yes"
-      ;;
-    --without-debug)
-      with_debug_flag="no"
-      if test "x$fast_flag" != "xyes" ; then
-        fast_flag="generic"
-      fi
-      ;;
-    --use-comment)
-      without_comment="no"
-      ;;
-    --with-fast-mutexes)
-      with_fast_mutexes="yes"
-      ;;
-    --without-fast-mutexes)
-      with_fast_mutexes="no"
-      ;;
-    --without-perfschema)
-      with_perfschema="no"
-      ;;
-    --with-mso)
-      with_mso="yes"
-      ;;
-    --use-tcmalloc)
-      use_tcmalloc="yes"
-      ;;
-    --with-debug)
-      with_debug_flag="yes"
-      fast_flag="no"
-      ;;
-    --extra-debug-flag)
-      shift
-      extra_debug_flags="$extra_debug_flags -D$1"
-      ;;
-    --debug)
-      compile_debug_flag="yes"
-      ;;
-    --no-developer)
-      developer_flag="no"
-      ;;
-    --developer)
-      developer_flag="yes"
-      ;;
-    --compiler=*)
-      compiler=`get_key_value "$1"`
-      parse_compiler
-      ;;
-    --generate-feedback)
-      shift
-      GENERATE_FEEDBACK_PATH="$1"
-      ;;
-    --use-feedback)
-      shift
-      USE_FEEDBACK_PATH="$1"
-      ;;
-    --cpu=*)
-      cpu_type=`get_key_value "$1"`
-      parse_cpu_type
-      ;;
-    --warning-mode=*)
-      warning_mode=`get_key_value "$1"`
-      parse_warning_mode
-      ;;
-    --warnings)
-      warning_mode="normal"
-      ;;
-    --32)
-      if test "x$explicit_size_set" != "x" ; then
-        echo "Cannot set both --32 and --64"
-        exit 1
-      fi
-      explicit_size_set="yes"
-      m64="no"
-      ;;
-    --64)
-      if test "x$explicit_size_set" != "x" ; then
-        echo "Cannot set both --32 and --64"
-        exit 1
-      fi
-      explicit_size_set="yes"
-      m64="yes"
-      ;;
-    --package=*)
-      package=`get_key_value "$1"`
-      parse_package
-      ;;
-    --parallelism=*)
-      parallelism=`get_key_value "$1"`
-      ;;
-    --configure-only)
-      just_configure="yes"
-      ;;
-    --print-only|--just-print)
-      just_print="yes"
-      ;;
-    --static-linking)
-      static_linking_flag="yes"
-      ;;
-    --strip)
-      strip_flag="yes"
-      ;;
-    --error-inject)
-      error_inject_flag="yes"
-      ;;
-    --valgrind)
-      valgrind="yes"
-      ;;
-    --fast)
-      fast_flag="yes"
-      ;;
-    --with-flags)
-      shift
-      break
-      ;;
-    --with-help)
-      with_usage
-      exit 0
-      ;;
-    --sysadmin-help)
-      sysadmin_usage
-      exit 0
-      ;;
-    --developer-help)
-      developer_usage
-      exit 0
-      ;;
-    --extended-help)
-      extended_usage
-      exit 0
-      ;;
-    --help)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown option '$1'"
-      exit 1
-      ;;
-    esac
-    shift
-  done
-  for flag in $@
-  do
-    with_flags="$with_flags $flag"
-  done
-}
-
-#
-# We currently only support Linux, FreeBSD/OpenBSD, Mac OS X and Solaris
-#
-check_os()
-{
-  case "`uname -s`" in
-    Linux)
-      os="linux"
-      ;;
-    FreeBSD|OpenBSD)
-      os="bsd"
-      ;;
-    Darwin)
-      os="MacOSX"
-      ;;
-    SunOS)
-      os="Solaris"
-      ;;
-    *)
-      os="Unknown"
-      ;;
-  esac
-
-}
-
-set_cpu_base()
-{
-  if test "x$cpu_type" = "x" ; then
-    if test "x$cpu_arg" = "x" ; then
-      usage "CPU type not discovered, cannot proceed"
-      exit 1
-    fi
-    case "$cpu_arg" in
-      core2 | nocona | prescott | pentium* | i*86 )
-        # Intel CPU
-        cpu_base_type="x86"
-        ;;
-      athlon* | opteron* | k6 | k8 )
-        # AMD CPU
-        cpu_base_type="x86"
-        ;;
-      sparc )
-        cpu_base_type="sparc"
-        ;;
-      itanium )
-        cpu_base_type="itanium"
-        ;;
-      * )
-        usage "CPU type $cpu_arg not handled by this script"
-        exit 1
-        ;;
-    esac
-  else
-    cpu_base_type="$cpu_type"
-    check_cpu_cflags=""
-  fi
-  if test "x$os" = "xMacOSX" ; then
-    if test "x$m64" = "x" ; then
-      m64="no"
-    fi
-  elif test "x$os" = "xSolaris" ; then
-    if test "x$m64" = "x" ; then
-      m64="yes"
-    fi
-  elif test "x$m64" = "x" ; then
-    if test "x$cpu_arg" = "xnocona" || test "x$cpu_arg" = "xcore2" || \
-       test "x$cpu_arg" = "xathlon64" || test "x$cpu_arg" = "xopteron" ; then
-      m64="yes"
-    else
-      m64="no"
-    fi
-  fi
-  echo "Discovered CPU of type $cpu_base_type ($cpu_arg) on $os"
-  if test "x$m64" = "xyes" ; then
-    echo "Will compile 64-bit binaries"
-  else
-    echo "Will compile 32-bit binaries"
-  fi
-  return 0
-}
-
-#
-# Add to the variable commands with the configure command
-# 
-init_configure_commands()
-{
-  path=`dirname $0`
-  cp $path/cmake_configure.sh $path/../configure
-  chmod +x $path/../configure
-  cflags="$c_warnings $base_cflags $compiler_flags"
-  cxxflags="$cxx_warnings $base_cxxflags $compiler_flags"
-  configure="./configure $base_configs $with_flags"
-
-  env_flags="CC=\"$CC\" CFLAGS=\"$cflags\" CXX=\"$CXX\" CXXFLAGS=\"$cxxflags\""
-  if test "x$LDFLAGS" != "x" ; then
-    env_flags="$env_flags LDFLAGS=\"$LDFLAGS\""
-  fi
-  if test "x$ASFLAGS" != "x" ; then
-    env_flags="$env_flags ASFLAGS=\"$ASFLAGS\""
-  fi
-  commands="$commands
-    $env_flags $configure"
-} 
-
-#
-# Initialise the variable commands with the commands needed to generate
-# the configure script.
-#
-init_auto_commands()
-{
-  set_libtoolize_version
-  commands="\
-  $make -k maintainer-clean || true
-  /bin/rm -rf */.deps/*.P configure config.cache
-  /bin/rm -rf  storage/*/configure storage/*/config.cache autom4te.cache
-  /bin/rm -rf storage/*/autom4te.cache;"
-#
-# --add-missing instructs automake to install missing auxiliary files
-# and --force to overwrite them if they already exist
-#
-  commands="$commands
-  aclocal || die \"Can't execute aclocal\"
-  autoheader || die \"Can't execute autoheader\"
-  $LIBTOOLIZE --automake --copy --force || die \"Can't execute libtoolize\"
-  automake --add-missing --copy --force || die \"Can't execute automake\"
-  autoconf || die \"Can't execute autoconf\""
-}
-
-#
-# Add to the variable commands the make command and possibly also
-# strip commands
-#
-add_make_commands()
-{
-  AM_MAKEFLAGS="-j $parallelism"
-  commands="$commands
-  $make $AM_MAKEFLAGS"
-
-  if test "x$strip_flag" = "xyes" ; then
-    commands="$commands
-    mkdir -p tmp
-    nm --numeric-sort sql/mysqld  > tmp/mysqld.sym
-    objdump -d sql/mysqld > tmp/mysqld.S
-    strip sql/mysqld
-    strip storage/ndb/src/kernel/ndbd
-    strip storage/ndb/src/mgmsrv/ndb_mgmd
-    strip storage/ndb/src/mgmclient/ndb_mgm"
-  fi
-}
-
-#
-# Set make version, but only gmake is supported :)
-#
-set_make_version()
-{
-  if gmake --version > /dev/null 2>&1
-  then
-    make=gmake
-  else
-    make=make
-  fi
-  if test "x`$make --version | grep GNU`" = "x" ; then
-    die "Only gmake is supported"
-  fi
-}
-
-#
-# Find a libtoolize binary, both libtoolize and glibtoolize are
-# ok, use first found.
-#
-set_libtoolize_version()
-{
-  LIBTOOLIZE=not_found
-  save_ifs="$IFS"; IFS=':'
-  for dir in $PATH
-  do
-    if test -x $dir/libtoolize
-    then
-      LIBTOOLIZE=libtoolize
-      echo "Found libtoolize in $dir"
-      break
-    fi
-    if test -x $dir/glibtoolize
-    then
-      LIBTOOLIZE=glibtoolize
-      echo "Found glibtoolize in $dir"
-      break
-    fi
-  done
-  IFS="$save_ifs"
-  if test "x$LIBTOOLIZE" = "xnot_found" ; then
-    die "Found no libtoolize version, quitting here"
-  fi
-  return
-}
-
-#
-# If ccache (a compiler cache which reduces build time)
-# (http://samba.org/ccache) is installed, use it.
-# We use 'grep' and hope that 'grep' works as expected
-# (returns 0 if finds lines)
-# We do not use ccache when gcov is used. Also only when
-# gcc is used.
-#
-set_ccache_usage()
-{
-  if test "x$compiler" = "xgcc" ; then
-    if ccache -V > /dev/null 2>&1 && test "$USING_GCOV" != "1"
-    then
-      echo "$CC" | grep "ccache" > /dev/null || CC="ccache $CC"
-      echo "$CXX" | grep "ccache" > /dev/null || CXX="ccache $CXX"
-    fi
-  fi
-}
-
-#
-# Set flags for various build configurations.
-# Used in -valgrind builds
-#
-set_valgrind_flags()
-{
-  if test "x$valgrind_flag" = "xyes" ; then
-    loc_valgrind_flags="-UFORCE_INIT_OF_VARS -DHAVE_purify "
-    loc_valgrind_flags="$loc_valgrind_flags -DMYSQL_SERVER_SUFFIX=-valgrind-max"
-    compiler_flags="$compiler_flags $loc_valgrind_flags"
-    with_flags="$with_flags --with-valgrind"
-  fi
-}
-
-#
-# Set up warnings; default is to use no warnings, but if warning_mode
-# is used a lot of warning flags are set up. These flags are valid only
-# for gcc, so for other compilers we ignore the warning_mode.
-#
-set_warning_flags()
-{
-  if test "x$developer_flag" = "xyes" && test "x$warning_mode" = "x" ; then
-    warning_mode="normal"
-  fi
-  if test "x$compiler" = "xgcc" ; then
-    if test "x$warning_mode" = "normal" || test "x$warning_mode" = "extra" ; then
-# Both C and C++ warnings
-      warnings="$warnings -Wimplicit -Wreturn-type -Wswitch -Wtrigraphs"
-      warnings="$warnings -Wcomment -W"
-      warnings="$warnings -Wchar-subscripts -Wformat -Wparentheses -Wsign-compare"
-      warnings="$warnings -Wwrite-strings -Wunused-function -Wunused-label"
-      warnings="$warnings -Wunused-value -Wunused-variable -Wno-uninitialized"
-
-      if test "x$warning_mode" = "extra" ; then
-        warnings="$warnings -Wshadow"
-      fi
-# C warnings
-      c_warnings="$warnings -Wunused-parameter"
-# C++ warnings
-      cxx_warnings="$warnings -Woverloaded-virtual -Wsign-promo -Wreorder"
-      cxx_warnings="$warnings -Wctor-dtor-privacy -Wnon-virtual-dtor"
-      compiler_flags="$compiler_flags -Wuninitialized"
-    elif test "x$warning_mode" = "xpedantic" ; then
-      warnings="-W -Wall -ansi -pedantic -Wno-long-long -D_POSIX_SOURCE"
-      c_warnings="$warnings"
-      cxx_warnings="$warnings -std=c++98"
-# Reset CPU flags (-mtune), they don't work in -pedantic mode
-     check_cpu_cflags=""
-    fi
-  fi
-}
-
-#
-# Used in -debug builds
-#
-set_with_debug_flags()
-{
-  if test "x$with_debug_flag" = "xyes" ; then
-    if test "x$developer_flag" = "xyes" ; then
-      loc_debug_flags="-DUNIV_MUST_NOT_INLINE -DEXTRA_DEBUG"
-      loc_debug_flags="$loc_debug_flags -Wuninitialized -DFORCE_INIT_OF_VARS"
-      loc_debug_flags="$loc_debug_flags -DSAFEMALLOC"
-      compiler_flags="$compiler_flags $loc_debug_flags"
-    fi
-    compiler_flags="$compiler_flags $extra_debug_flags"
-  fi
-}
-
-#
-# Flag for optimizing builds for developers.
-#
-set_no_omit_frame_pointer_for_developers()
-{
-  if test "x$fast_flag" != "xno" ; then
-    if test "x$developer_flag" = "xyes" && test "x$compiler" = "xgcc" ; then
-# Be as fast as we can be without losing our ability to backtrace.
-      compiler_flags="$compiler_flags -fno-omit-frame-pointer"
-    fi
-  fi
-}
-
-#
-# Add -g to all builds that requested debug information in build
-#
-set_debug_flag()
-{
-  if test "x$compile_debug_flag" = "xyes" ; then
-    compiler_flags="$compiler_flags -g"
-  fi
-}
-
-#
-# We compile in SSL support if we can, this isn't possible if CXX
-# and CC aren't the same and we're not using GCC.
-# 
-set_ssl()
-{
-  if test "x$compiler" = "xgcc" && \
-     test "x$CC" = "x$CXX" ; then
-    base_configs="$base_configs --with-ssl"
-  fi
-}
-
-#
-# Base options used by all packages
-#
-# SSL library to use. --with-ssl selects the bundled yaSSL
-# implementation of SSL. To use openSSL, you must point out the location
-# of the openSSL headers and libs on your system.
-# For example: --with-ssl=/usr
-#
-set_base_configs()
-{
-  base_configs="$base_configs --prefix=$prefix"
-  base_configs="$base_configs --libexecdir=$prefix/bin"
-  base_configs="$base_configs --with-zlib-dir=bundled"
-  if test "x$datadir" = "x" ; then
-    base_configs="$base_configs --localstatedir=$prefix/data"
-  else
-    base_configs="$base_configs --localstatedir=$datadir"
-  fi
-  if test "x$with_debug_flag" = "xyes" ; then
-    base_configs="$base_configs --with-debug"
-  fi
-  base_configs="$base_configs --enable-local-infile"
-  base_configs="$base_configs --enable-thread-safe-client"
-  base_configs="$base_configs --with-big-tables"
-  base_configs="$base_configs --with-extra-charsets=all"
-  if test "x$with_fast_mutexes" = "xyes" ; then
-    base_configs="$base_configs --with-fast-mutexes"
-  fi
-  base_configs="$base_configs --with-pic"
-  base_configs="$base_configs --with-csv-storage-engine"
-  if test "x$with_perfschema" != "xno" ; then
-    base_configs="$base_configs --with-perfschema"
-  fi
-  base_configs="$base_configs --with-libevent"
-}
-
-#
-# Add all standard engines and partitioning
-#
-set_max_engines()
-{
-  engine_configs="--with-plugins=max --with-plugin-maria --with-maria-tmp-tables"
-  engine_configs="$engine_configs --without-plugin-innodb_plugin"
-  base_configs="$base_configs $engine_configs"
-}
-
-set_ndb_engine()
-{
-  base_configs="$base_configs --with-ndbcluster"
-  base_configs="$base_configs --without-ndb-debug"
-}
-
-set_pro_package()
-{
-  if test "x$without_comment" != "xyes" ; then
-    base_configs="$base_configs --with-comment=\"Pro $version_text built from source\""
-  fi
-  if test "x$with_debug_flag" = "xyes" ; then
-    base_configs="$base_configs --with-server-suffix=\"-debug\""
-  fi
-}
-
-set_classic_package()
-{
-  if test "x$without_comment" != "xyes" ; then
-    base_configs="$base_configs --with-comment=\"Classic $version_text built from source\""
-  fi
-  if test "x$with_debug_flag" = "xyes" ; then
-    base_configs="$base_configs --with-server-suffix=\"-debug\""
-  fi
-  base_configs="$base_configs --without-example-storage-engine"
-}
-
-#
-# Special handling of readline; use readline from the MySQL
-# distribution if building a GPL version, otherwise use libedit.
-#
-set_readline_package()
-{
-  if test -d "$path/../cmd-line-utils/readline" && test "x$gpl" = "xyes" ; then
-    base_configs="$base_configs --with-readline"
-  elif test -d "$path/../cmd-line-utils/libedit" ; then
-    base_configs="$base_configs --with-libedit"
-  fi
-}
-
-#
-# If fast flag set by user we also add architecture as discovered to 
-# compiler flags to make binary optimised for architecture at hand. 
-# We use this feature on gcc compilers.
-#
-set_gcc_special_options()
-{
-  if test "x$fast_flag" = "xyes" && test "x$compiler" = "xgcc" ; then
-    compiler_flags="$compiler_flags $check_cpu_cflags"
-  fi
-}
-
-#
-# If we discover a Core 2 Duo architecture and we have enabled the fast
-# flag, we enable a compile especially optimised for Core 2 Duo. This
-# feature is currently available on Intel's icc compiler only.
-#
-set_icc_special_options()
-{
-  if test "x$fast_flag" = "xyes" && test "x$cpu_arg" = "xcore2" && \
-     test "x$compiler" = "xicc" ; then
-    compiler_flags="$compiler_flags -xT"
-  fi
-}
-
-set_cc_and_cxx_for_gcc()
-{
-  if test "x$CC" = "x" ; then
-    CC="gcc -static-libgcc -fno-exceptions"
-  fi
-  if test "x$CXX" = "x" ; then
-    CXX="gcc -static-libgcc -fno-exceptions"
-  fi
-}
-
-set_cc_and_cxx_for_icc()
-{
-  if test "x$CC" = "x" ; then
-    CC="icc -static-intel -static-libgcc"
-  fi
-  if test "x$CXX" = "x" ; then
-    CXX="icpc -static-intel -static-libgcc"
-  fi
-}
-
-set_cc_and_cxx_for_open64()
-{
-  if test "x$CC" = "x" ; then
-    CC="opencc -static-libgcc -fno-exceptions"
-  fi
-  if test "x$CXX" = "x" ; then
-    CXX="openCC -static-libgcc -fno-exceptions"
-  fi
-}
-
-set_cc_and_cxx_for_forte()
-{
-  if test "x$CC" = "x" ; then
-    CC="cc"
-  fi
-  if test "x$CXX" = "x" ; then
-    CXX="CC"
-  fi
-}
-
-#
-# FreeBSD Section
-#
-set_bsd_configs()
-{
-  if test "x$cpu_base_type" != "xx86" ; then
-    usage "Only x86 CPUs supported for FreeBSD"
-    exit 1
-  fi
-  if test "x$compiler" != "xgcc" ; then
-    usage "Only gcc supported for FreeBSD"
-    exit 1
-  fi
-  base_configs="$base_configs --enable-assembler"
-  if test "x$fast_flag" != "xno" ; then
-    compiler_flags="$compiler_flags -O3"
-  else
-    compiler_flags="$compiler_flags -O0"
-  fi
-  set_cc_and_cxx_for_gcc
-}
-
-check_64_bits()
-{
-  echo "Checking for 32/64-bits compilation"
-  echo "int main() { return 0; }" > temp_test.c
-  if test "x$m64" = "xyes" ; then
-    cmd="$CC $compile_flags -m64 temp_test.c"
-    if ! $cmd 2>1 ; then
-      m64="no"
-      echo "Changing to 32-bits since 64-bits didn't work"
-    else
-      echo "Will use 64-bits"
-    fi
-  else
-    cmd="$CC $compile_flags -m32 temp_test.c"
-    if ! $cmd 2>1 ; then
-      m64="yes"
-      echo "Changing to 64-bits since 32-bits didn't work"
-    else
-      echo "Will use 32-bits"
-    fi
-  fi
-  rm temp_test.c
-}
-
-#
-# Get GCC version
-#
-get_gcc_version()
-{
-  # check if compiler is gcc and dump its version
-  cc_verno=`$cc -dumpversion 2>/dev/null`
-  if test "x$?" = "x0" ; then
-    set -- `echo $cc_verno | tr '.' ' '`
-    cc_ver="GCC"
-    cc_major=$1
-    cc_minor=$2
-    cc_patch=$3
-    gcc_version=`expr $cc_major '*' 100 '+' $cc_minor`
-  fi
-}
-
-#
-# Link time optimizer (interprocedural optimizations) for Open64
-#
-check_for_open64_link_time_optimizer()
-{
-  if test "x$with_link_time_optimizer" = "xyes" ; then
-    compiler_flags="$compiler_flags -ipa"
-    LDFLAGS="$LDFLAGS -ipa"
-  fi
-}
-
-#
-# Link time optimizer (interprocedural optimizations) for icc
-#
-check_for_icc_link_time_optimizer()
-{
-  if test "x$with_link_time_optimizer" = "xyes" ; then
-    compiler_flags="$compiler_flags -ipo"
-    LDFLAGS="$LDFLAGS -ipo"
-  fi
-}
-
-#
-# Link time optimizer (interprocedural optimizations) for forte
-#
-check_for_forte_link_time_optimizer()
-{
-  if test "x$with_link_time_optimizer" = "xyes" ; then
-    compiler_flags="$compiler_flags -ipo"
-    LDFLAGS="$LDFLAGS -ipo"
-  fi
-}
-
-#
-# Link Time Optimizer in GCC (LTO) uses a parameter -flto
-# which was added to GCC 4.5, if --with-link-time-optimizer
-# is set then use this feature
-#
-check_for_gcc_link_time_optimizer()
-{
-  get_gcc_version
-  if test "$gcc_version" -ge 405 && \
-     test "x$with_link_time_optimizer" = "xyes" ; then
-    compiler_flags="$compiler_flags -flto"
-    LDFLAGS="$LDFLAGS -flto"
-  fi
-}
-
-set_feedback_for_gcc()
-{
-  if test "x$GENERATE_FEEDBACK_PATH" != "x" ; then
-    compiler_flags="$compiler_flags -fprofile-generate"
-    compiler_flags="$compiler_flags -fprofile-dir=$GENERATE_FEEDBACK_PATH"
-  elif test "x$USE_FEEDBACK_PATH" != "x" ; then
-    compiler_flags="$compiler_flags -fprofile-use"
-    compiler_flags="$compiler_flags -fprofile-correction"
-    compiler_flags="$compiler_flags -fprofile-dir=$USE_FEEDBACK_PATH"
-  fi
-}
-
-set_feedback_for_open64()
-{
-  if test "x$GENERATE_FEEDBACK_PATH" != "x" ; then
-    compiler_flags="$compiler_flags --fb-create=$GENERATE_FEEDBACK_PATH/feedback"
-  elif test "x$USE_FEEDBACK_PATH" != "x" ; then
-    compiler_flags="$compiler_flags --fb-opt=$USE_FEEDBACK_PATH/feedback"
-  fi
-}
-
-#
-# Linux Section
-#
-set_linux_configs()
-{
-# Default to use --with-fast-mutexes on Linux
-  if test "x$with_fast_mutexes" = "x" ; then
-    base_configs="$base_configs --with-fast-mutexes"
-  fi
-  if test "x$cpu_base_type" != "xx86" && \
-     test "x$cpu_base_type" != "xitanium" ; then
-    usage "Only x86 and Itanium CPUs supported for Linux"
-    exit 1
-  fi
-  if test "x$use_tcmalloc" = "xyes" ; then
-    base_configs="$base_configs --with-mysqld-libs=-ltcmalloc_minimal"
-  fi
-  if test "x$cpu_base_type" = "xx86" ; then
-    base_configs="$base_configs --enable-assembler"
-  fi
-  if test "x$compiler" = "xgcc" ; then
-    set_cc_and_cxx_for_gcc
-    if test "x$fast_flag" != "xno" ; then
-      if test "x$fast_flag" = "xyes" ; then
-        compiler_flags="$compiler_flags -O3"
-        check_for_gcc_link_time_optimizer
-      else
-        compiler_flags="$compiler_flags -O3"
-      fi
-    else
-      compiler_flags="$compiler_flags -O0"
-    fi
-    set_feedback_for_gcc
-# configure will set proper compiler flags for gcc on Linux
-  elif test "x$compiler" = "xicc" ; then
-    compiler_flags="$compiler_flags -mp -restrict"
-    set_cc_and_cxx_for_icc
-    if test "x$cpu_base_type" = "xitanium" ; then
-      compiler_flags="$compiler_flags -no-ftz"
-    fi
-    if test "x$fast_flag" != "xno" ; then
-      compiler_flags="$compiler_flags -O3 -unroll2 -ip"
-      if test "x$fast_flag" = "xyes" ; then
-        check_for_icc_link_time_optimizer
-      fi
-    fi
-  elif test "x$compiler" = "xopen64" ; then
-    set_cc_and_cxx_for_open64
-    if test "x$fast_flag" != "xno" ; then
-      if test "x$fast_flag" = "xyes" ; then
-        compiler_flags="$compiler_flags -O3"
-#       Generate code specific for the machine you run on
-        compiler_flags="$compiler_flags -march=auto"
-        check_for_open64_link_time_optimizer
-        if test "x$with_mso" = "xyes" ; then
-          compiler_flags="$compiler_flags -mso"
-        fi
-      else
-        compiler_flags="$compiler_flags -O3"
-      fi
-    fi
-    set_feedback_for_open64
-  else
-    usage "Only gcc,icc and Open64 compilers supported for Linux"
-    exit 1
-  fi
-  check_64_bits
-  if test "x$m64" = "xyes" ; then
-    compiler_flags="$compiler_flags -m64"
-  else
-    compiler_flags="$compiler_flags -m32"
-  fi
-}
-
-#
-# Solaris Section
-#
-set_solaris_configs()
-{
-# Use mtmalloc as malloc, see Tim Cook blog
-# For information on optimal compiler settings, see article at
-# http://developers.sun.com/solaris/articles/mysql_perf_tune.html
-# by Luojia Chen at Sun.
-  base_configs="$base_configs --with-named-curses=-lcurses"
-  case "`uname -a`" in
-    *5.8* | *5.9* )
-      ;;
-
-    *5.10* | *5.11*)
-      base_configs="$base_configs --with-mysqld-libs=-lmtmalloc"
-      ;;
-    *)
-      usage "Only versions 8,9, 10 and 11 supported for Solaris"
-      exit 1
-  esac
-  if test "x$cpu_base_type" != "xx86" && \
-     test "x$cpu_base_type" != "xsparc" ; then
-    usage "Only x86 and Sparc CPUs supported for Solaris"
-    exit 1
-  fi
-  if test "x$compiler" != "xgcc" && \
-     test "x$compiler" != "xforte" ; then
-    usage "Only gcc and Forte compilers supported for Solaris"
-    exit 1
-  fi
-  if test "x$m64" = "xyes" ; then
-    compiler_flags="$compiler_flags -m64"
-    LDFLAGS="-m64"
-    ASFLAGS="$ASFLAGS -m64"
-  else
-    compiler_flags="$compiler_flags -m32"
-    LDFLAGS="-m32"
-    ASFLAGS="$ASFLAGS -m32"
-  fi
-  if test "x$compiler" = "xgcc" ; then
-    set_cc_and_cxx_for_gcc
-    if test "x$cpu_base_type" != "xx86" ; then
-      usage "gcc currently not supported for Solaris on SPARC"
-      exit 1
-    fi
-    if test "x$fast_flag" = "xyes" ; then
-      LDFLAGS="$LDFLAGS -O3"
-      compiler_flags="$compiler_flags -O3"
-      check_for_gcc_link_time_optimizer
-    else
-      if test "x$fast_flag" = "xgeneric" ; then
-        LDFLAGS="$LDFLAGS -O2"
-        compiler_flags="$compiler_flags -O2"
-      else
-        LDFLAGS="$LDFLAGS -O0"
-        compiler_flags="$compiler_flags -O0"
-      fi
-    fi
-  else
-#Using Forte compiler (SunStudio)
-    set_cc_and_cxx_for_forte
-    compiler_flags="$compiler_flags -mt"
-    LDFLAGS="$LDFLAGS -mt"
-    compiler_flags="$compiler_flags -fsimple=1"
-    compiler_flags="$compiler_flags -ftrap=%none"
-    compiler_flags="$compiler_flags -xbuiltin=%all"
-    compiler_flags="$compiler_flags -xlibmil"
-    compiler_flags="$compiler_flags -xlibmopt"
-    if test "x$fast_flag" = "xyes" ; then
-      compiler_flags="$compiler_flags -xtarget=native"
-      compiler_flags="$compiler_flags -xunroll=3"
-      check_for_forte_link_time_optimizer
-    else
-      compiler_flags="$compiler_flags -xtarget=generic"
-    fi
-    if test "x$cpu_base_type" = "xx86" ; then
-      compiler_flags="$compiler_flags -nofstore"
-      base_cxx_flags="$base_cxx_flags -features=no%except"
-      if test "x$fast_flag" = "xyes" ; then
-        compiler_flags="$compiler_flags -xregs=frameptr"
-        compiler_flags="$compiler_flags -xO4"
-      else
-        compiler_flags="$compiler_flags -xregs=no%frameptr"
-        if test "x$fast_flag" = "xgeneric" ; then
-          compiler_flags="$compiler_flags -xO2"
-        else
-          compiler_flags="$compiler_flags -xO0"
-        fi
-      fi
-    else
-#Using SPARC cpu with SunStudio (Forte) compiler
-      ASFLAGS="$ASFLAGS -xarch=sparc"
-      LDFLAGS="$LDFLAGS -xarch=sparc"
-      base_cxxflags="$base_cxxflags -noex"
-      base_cflags="$base_cflags -xstrconst"
-      compiler_flags="$compiler_flags -xarch=sparc"
-      if test "x$fast_flag" = "xyes" ; then
-        compiler_flags="$compiler_flags -xbinopt=prepare"
-        LDFLAGS="$LDFLAGS -xbinopt=prepare"
-        compiler_flags="$compiler_flags -xO4"
-      elif test "x$fast_flag" = "xgeneric" ; then
-        compiler_flags="$compiler_flags -xO3"
-      else
-        compiler_flags="$compiler_flags -xO0"
-      fi
-    fi
-  fi
-}
-
-#
-# Mac OS X Section
-#
-set_macosx_configs()
-{
-  if test "x$cpu_base_type" != "xx86" || test "x$compiler" != "xgcc" ; then
-    usage "Only gcc/x86 supported for Mac OS X"
-    exit 1
-  fi
-#
-# Optimize for space as long as it doesn't affect performance, use some
-# optimisations also when not in fast mode.
-#
-  base_cxxflags="$base_cxxflags -felide-constructors"
-  compiler_flags="$compiler_flags -fno-common"
-  if test "x$m64" = "xyes" ; then
-    compiler_flags="$compiler_flags -m64"
-    compiler_flags="$compiler_flags -arch x86_64"
-  else
-    compiler_flags="$compiler_flags -m32"
-    compiler_flags="$compiler_flags -arch i386"
-  fi
-  if test "x$fast_flag" != "xno" ; then
-    compiler_flags="$compiler_flags -Os"
-  else
-    compiler_flags="$compiler_flags -O0"
-  fi
-  set_cc_and_cxx_for_gcc
-}
-
-#
-# Use static linking for own modules and dynamic linking for system
-# modules unless specifically requested to do everything statically.
-# Should normally not be used; static_linking_flag kept in case someone 
-# really needs it. Available only if developer flag is also set.
-#
-set_static_link_configs()
-{
-  if test "x$static_linking_flag" = "xyes" && test "x$developer_flag" = "xyes" ; then
-    loc_static_link="--with-mysqld-ldflags=\"-all-static\""
-    loc_static_link="$loc_static_link --with-client-ldflags=\"-all-static\""
-  else
-    loc_static_link="--with-mysqld-ldflags=\"-static\""
-    loc_static_link="$loc_static_link --with-client-ldflags=\"-static\""
-  fi
-  base_configs="$base_configs $loc_static_link"
-}
-
-#
-# Enable error injection in MySQL Server (for developer build only -
-# extra check for developer flag required).
-#
-set_error_inject_configs()
-{
-  if test "x$error_inject_flag" = "xyes" && test "x$developer_flag" = "xyes" ; then
-    base_configs="$base_configs --with-error-inject"
-    if test "x$package" = "xndb" || test "x$package" = "xextended" ; then
-      base_configs="$base_configs --with-ndb-ccflags='-DERROR_INSERT'"
-    fi
-  fi
-}
-
-set_default_package()
-{
-  if test "x$package" = "x" ; then
-      package="extended"
-  fi
-}
-
-set_defaults_based_on_environment()
-{
-  if test ! -z "$MYSQL_DEVELOPER" ; then
-    developer_flag="yes"
-  fi
-  if test ! -z "$MYSQL_DEVELOPER_DEBUG" ; then
-    with_debug_flag="yes"
-    fast_flag="no"
-  fi
-  if test ! -z "$MYSQL_DEVELOPER_PACKAGE" ; then
-    package="$MYSQL_DEVELOPER_PACKAGE"
-    parse_package
-  fi
-}
-
-########################################################################
-
-if test ! -f sql/mysqld.cc ; then
-  die "You must run this script from the MySQL top-level directory"
-fi
-
-cpu_type=
-package=
-prefix="/usr/local/mysql"
-parallelism="8"
-fast_flag="generic"
-compiler="gcc"
-gpl="yes"
-version_text=
-developer_flag="no"
-just_configure=
-warning_mode=
-with_flags=
-error_inject_flag=
-with_debug_flag=
-compile_debug_flag=
-strip_flag=
-valgrind_flag=
-static_linking_flag=
-compiler_flags=
-os=
-cpu_base_type=
-warnings=
-c_warnings=
-cflags=
-base_cflags=
-cxx_warnings=
-base_cxxflags=
-base_configs=
-debug_flags=
-cxxflags=
-extra_debug_flags=
-m64=
-explicit_size_set=
-datadir=
-commands=
-engine_configs=
-ASFLAGS=
-LDFLAGS=
-use_tcmalloc=
-without_comment="yes"
-with_fast_mutexes=
-with_perfschema="yes"
-with_link_time_optimizer=
-with_mso=
-gcc_version="0"
-generate_feedback_path=
-use_feedback_path=
-
-set_defaults_based_on_environment
-
-parse_options "$@"
-
-set_default_package
-
-set -e
-
-#
-# Check for the CPU and set up CPU specific flags. We may reset them
-# later.
-# This call sets the cpu_arg and check_cpu_args parameters
-#
-path=`dirname $0`
-if test "x$compiler" = "xgcc" ; then
-  compiler=
-fi
-. "$path/check-cpu"
-if test "x$compiler" = "x" ; then
-  compiler="gcc"
-fi
-check_os
-set_cpu_base
-if test "x$?" = "x1" ; then
-  exit 1
-fi
-
-#
-# Set up c_warnings and cxx_warnings; add to compiler_flags.
-# Possibly reset check_cpu_flags.
-#
-set_warning_flags
-
-#
-# Add to compiler_flags.
-#
-set_valgrind_flags
-set_with_debug_flags
-set_no_omit_frame_pointer_for_developers
-set_debug_flag
-set_gcc_special_options
-set_icc_special_options
-
-#
-# Definitions of various packages possible to compile. The default is to
-# build a source variant including all storage engines except InnoDB.
-#
-set_base_configs
-  version_text="GPL version"
-if test "x$package" = "xpro" ; then
-  set_max_engines
-  set_pro_package
-elif test "x$package" = "xclassic" ; then
-  set_classic_package
-else
-  die "No supported package was used, internal error"
-fi
-set_readline_package
-set_static_link_configs
-set_error_inject_configs
-
-#
-# This section handles flags for specific combinations of compilers,
-# operating systems, and processors.
-#
-
-if test "x$os" = "xlinux" ; then
-  set_linux_configs
-elif test "x$os" = "xSolaris" ; then
-  set_solaris_configs
-elif test "x$os" = "xMacOSX" ; then
-  set_macosx_configs
-elif test "x$os" = "xbsd" ; then
-  set_bsd_configs
-else
-  die "Operating system not supported by this script"
-fi
-set_ssl
-#
-# Final step before setting up commands is to set up proper make and
-# proper libtoolize versions, and to determine whether to use ccache.
-#
-set_make_version
-set_ccache_usage
-
-#
-# Set up commands variable from variables prepared for base 
-# configurations, compiler flags, and warnings flags.
-# 
-init_configure_commands
-
-if test "x$just_configure" != "xyes" ; then
-  add_make_commands
-fi
-
-#
-# The commands variable now contains the entire command to be run for
-# the build; we either execute it, or merely print it out.
-#
-echo "Running command:"
-echo "$commands"
-if test "x$just_print" != "xyes" ; then
-  eval "set -x; $commands"
-fi
diff --git a/BUILD/compile-amd64-debug-max-no-ndb b/BUILD/compile-amd64-debug-max-no-ndb
index 100a17163a4..d45a51eba54 100755
--- a/BUILD/compile-amd64-debug-max-no-ndb
+++ b/BUILD/compile-amd64-debug-max-no-ndb
@@ -20,6 +20,6 @@
 path=`dirname $0`
 . "$path/SETUP.sh"
 extra_flags="$amd64_cflags $debug_cflags"
-extra_configs="$amd64_configs $debug_configs $max_no_ndb_configs"
+extra_configs="$amd64_configs $debug_configs $max_configs"
 
 . "$path/FINISH.sh"
diff --git a/BUILD/compile-amd64-gprof-no-ndb b/BUILD/compile-amd64-gprof-no-ndb
index 9fd4c67155c..ef684274658 100755
--- a/BUILD/compile-amd64-gprof-no-ndb
+++ b/BUILD/compile-amd64-gprof-no-ndb
@@ -2,6 +2,6 @@
 path=`dirname $0`
 . "$path/SETUP.sh"
 extra_flags="$amd64_cflags -pg -g"
-extra_configs="$amd64_configs $max_no_ndb_configs --disable-shared $static_link"
+extra_configs="$amd64_configs $max_configs --disable-shared $static_link"
 
 . "$path/FINISH.sh"
diff --git a/BUILD/compile-amd64-max-sci b/BUILD/compile-amd64-max-sci
deleted file mode 100644
index fbcbba7920b..00000000000
--- a/BUILD/compile-amd64-max-sci
+++ /dev/null
@@ -1,23 +0,0 @@
-#! /bin/sh
-
-# Copyright (C) 2007 MySQL AB
-# Use is subject to license terms 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-
-path=`dirname $0`
-. "$path/SETUP.sh"
-extra_flags="$amd64_cflags $fast_cflags -g"
-extra_configs="$amd64_configs $max_configs --with-ndb-sci=/opt/DIS"
-
-. "$path/FINISH.sh"
diff --git a/BUILD/compile-bintar b/BUILD/compile-bintar
index 2b039e439c0..8434bf57a52 100755
--- a/BUILD/compile-bintar
+++ b/BUILD/compile-bintar
@@ -73,7 +73,7 @@ CC="gcc -static-libgcc" CXX="g++ -static-libgcc" CFLAGS="$FLAGS" CXXFLAGS="$FLAG
 	--without-docs --with-extra-charsets=all \
 	--with-libwrap --with-ssl --with-readline --with-libevent --with-zlib-dir=bundled \
 	--with-partition --with-embedded-server \
-	--with-plugins=max-no-ndb \
+	--with-plugins=max \
 	--without-plugin-innodb_plugin
 
 make $AM_MAKEFLAGS
diff --git a/BUILD/compile-dist b/BUILD/compile-dist
index becfea638f8..853fd339769 100755
--- a/BUILD/compile-dist
+++ b/BUILD/compile-dist
@@ -78,5 +78,5 @@ fi
 ./configure \
   --with-embedded-server \
   --with-perfschema \
-  --with-plugins=max-no-ndb
+  --with-plugins=max
 $gmake -j4
diff --git a/BUILD/compile-ndb-autotest b/BUILD/compile-ndb-autotest
deleted file mode 100755
index 691b309fb60..00000000000
--- a/BUILD/compile-ndb-autotest
+++ /dev/null
@@ -1,24 +0,0 @@
-#! /bin/sh
-
-# Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-
-path=`dirname $0`
-. "$path/SETUP.sh"
-
-extra_configs="$max_configs --with-ndb-test --with-ndb-ccflags='-DERROR_INSERT'"
-extra_flags="$fast_cflags $max_cflags -g"
-
-. "$path/FINISH.sh"
diff --git a/BUILD/compile-pentium-debug-max-no-ndb b/BUILD/compile-pentium-debug-max-no-ndb
index fa8069414b2..705164c20bc 100755
--- a/BUILD/compile-pentium-debug-max-no-ndb
+++ b/BUILD/compile-pentium-debug-max-no-ndb
@@ -19,6 +19,6 @@ path=`dirname $0`
 . "$path/SETUP.sh"
 
 extra_flags="$pentium_cflags $debug_cflags"
-extra_configs="$pentium_configs $debug_configs $max_no_ndb_configs"
+extra_configs="$pentium_configs $debug_configs $max_configs"
 
 . "$path/FINISH.sh"
diff --git a/BUILD/compile-pentium-valgrind-max-no-ndb b/BUILD/compile-pentium-valgrind-max-no-ndb
index c3ebb47cc22..4eb47cb2fe2 100755
--- a/BUILD/compile-pentium-valgrind-max-no-ndb
+++ b/BUILD/compile-pentium-valgrind-max-no-ndb
@@ -21,6 +21,6 @@ path=`dirname $0`
 . "$path/SETUP.sh"
 
 extra_flags="$pentium_cflags $debug_cflags $valgrind_flags"
-extra_configs="$pentium_configs $debug_configs $valgrind_configs $max_no_ndb_configs"
+extra_configs="$pentium_configs $debug_configs $valgrind_configs $max_configs"
 
 . "$path/FINISH.sh"
diff --git a/BUILD/compile-pentium64-max-sci b/BUILD/compile-pentium64-max-sci
deleted file mode 100644
index a19351308c5..00000000000
--- a/BUILD/compile-pentium64-max-sci
+++ /dev/null
@@ -1,25 +0,0 @@
-#! /bin/sh
-
-# Copyright (C) 2007 MySQL AB
-#  Use is subject to license terms
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 2 of the License.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-
-path=`dirname $0`
-. "$path/SETUP.sh"
-
-extra_flags="$pentium64_cflags $fast_cflags -g"
-extra_configs="$pentium_configs $max_configs --with-ndb-sci=/opt/DIS"
-
-. "$path/FINISH.sh"
diff --git a/BUILD/compile-ppc-debug-max-no-ndb b/BUILD/compile-ppc-debug-max-no-ndb
index ba7fe9aee5b..0642ddf7a57 100755
--- a/BUILD/compile-ppc-debug-max-no-ndb
+++ b/BUILD/compile-ppc-debug-max-no-ndb
@@ -20,6 +20,6 @@ path=`dirname $0`
 . "$path/SETUP.sh"
 
 extra_flags="$ppc_cflags $debug_cflags"
-extra_configs="$debug_configs $max_no_ndb_configs"
+extra_configs="$debug_configs $max_configs"
 
 . "$path/FINISH.sh"