Updated modules

bin/pt-archiver

@@ -2314,6 +2314,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -2368,8 +2370,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -2403,10 +2406,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -2415,7 +2421,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }
@@ -3262,10 +3269,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-deadlock-logger

@@ -1505,6 +1505,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -1559,8 +1561,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -1594,10 +1597,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -1606,7 +1612,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-duplicate-key-checker

@@ -481,6 +481,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -535,8 +537,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -570,10 +573,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -582,7 +588,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-find

@@ -1986,6 +1986,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -2040,8 +2042,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -2075,10 +2078,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -2087,7 +2093,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-heartbeat

@@ -222,10 +222,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 
@@ -1740,456 +1736,6 @@ if ( PTDEBUG ) {
 # End OptionParser package
 # ###########################################################################
 
-# ###########################################################################
-# Mo package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/Mo.pm
-#   t/lib/Mo.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-BEGIN {
-$INC{"Mo.pm"} = __FILE__;
-package Mo;
-our $VERSION = '0.30_Percona'; # Forked from 0.30 of Mo.
-
-{
-   no strict 'refs';
-   sub _glob_for {
-      return \*{shift()}
-   }
-
-   sub _stash_for {
-      return \%{ shift() . "::" };
-   }
-}
-
-use strict;
-use warnings qw( FATAL all );
-
-use Carp ();
-use Scalar::Util ();
-
-our %TYPES = (
-   Bool   => sub { !$_[0] || (defined $_[0] && &Scalar::Util::looks_like_number && $_[0] == 1) },
-   Num    => sub { defined $_[0] && &Scalar::Util::looks_like_number },
-   Int    => sub { defined $_[0] && &Scalar::Util::looks_like_number && $_[0] == int $_[0] },
-   Str    => sub { defined $_[0] },
-   Object => sub { defined $_[0] && &Scalar::Util::blessed },
-   FileHandle => sub { local $@; require IO::Handle; fileno($_[0]) && $_[0]->opened },
-
-   map {
-      my $type = /R/ ? $_ : uc $_;
-      $_ . "Ref" => sub { ref $_[0] eq $type }
-   } qw(Array Code Hash Regexp Glob Scalar)
-);
-
-our %metadata_for;
-{
-   package Mo::Object;
-
-   sub new {
-      my $class = shift;
-      my $args  = $class->BUILDARGS(@_);
-
-      my @args_to_delete;
-      while ( my ($attr, $meta) = each %{$metadata_for{$class}} ) {
-         next unless exists $meta->{init_arg};
-         my $init_arg = $meta->{init_arg};
-
-         if ( defined $init_arg ) {
-            $args->{$attr} = delete $args->{$init_arg};
-         }
-         else {
-            push @args_to_delete, $attr;
-         }
-      }
-
-      delete $args->{$_} for @args_to_delete;
-
-      for my $attribute ( keys %$args ) {
-         if ( my $coerce = $metadata_for{$class}{$attribute}{coerce} ) {
-            $args->{$attribute} = $coerce->($args->{$attribute});
-         }
-         if ( my $I = $metadata_for{$class}{$attribute}{isa} ) {
-            ( (my $I_name), $I ) = @{$I};
-            Mo::_check_type_constaints($attribute, $I, $I_name, $args->{$attribute});
-         }
-      }
-
-      while ( my ($attribute, $meta) = each %{$metadata_for{$class}} ) {
-         next unless $meta->{required};
-         Carp::confess("Attribute ($attribute) is required for $class")
-            if ! exists $args->{$attribute}
-      }
-
-      @_ = %$args;
-      my $self = bless $args, $class;
-
-      my @build_subs;
-      my $linearized_isa = mro::get_linear_isa($class);
-
-      for my $isa_class ( @$linearized_isa ) {
-         unshift @build_subs, *{ Mo::_glob_for "${isa_class}::BUILD" }{CODE};
-      }
-      exists &$_ && $_->( $self, @_ ) for grep { defined } @build_subs;
-      return $self;
-   }
-
-   sub BUILDARGS {
-      shift;
-      my $ref;
-      if ( @_ == 1 && ref($_[0]) ) {
-         Carp::confess("Single parameters to new() must be a HASH ref")
-            unless ref($_[0]) eq ref({});
-         $ref = {%{$_[0]}} # We want a new reference, always
-      }
-      else {
-         $ref = { @_ };
-      }
-      return $ref;
-   }
-}
-
-my %export_for;
-sub Mo::import {
-    warnings->import(qw(FATAL all));
-    strict->import();
-    
-    my $caller     = scalar caller(); # Caller's package
-    my $caller_pkg = $caller . "::"; # Caller's package with :: at the end
-    my (%exports, %options);
-
-    my (undef, @features) = @_;
-    my %ignore = ( map { $_ => 1 } qw( is isa init_arg builder buildargs clearer predicate build handles default required ) );
-    for my $feature (grep { !$ignore{$_} } @features) {
-      { local $@; require "Mo/$feature.pm"; }
-      {
-         no strict 'refs';
-         &{"Mo::${feature}::e"}(
-                  $caller_pkg,
-                  \%exports,
-                  \%options,
-                  \@_
-            );
-      }
-    }
-
-    return if $exports{M}; 
-
-    %exports = (
-        extends => sub {
-            for my $class ( map { "$_" } @_ ) {
-               $class =~ s{::|'}{/}g;
-               { local $@; eval { require "$class.pm" } } # or warn $@;
-            }
-            _set_package_isa($caller, @_);
-            _set_inherited_metadata($caller);
-        },
-        has => sub {
-            my $names = shift;
-            for my $attribute ( ref $names ? @$names : $names ) {
-               my %args   = @_;
-               my $method = ($args{is} || '') eq 'ro'
-                  ? sub {
-                     Carp::confess("Cannot assign a value to a read-only accessor at reader ${caller_pkg}${attribute}")
-                        if $#_;
-                     return $_[0]{$attribute};
-                  }
-                  : sub {
-                     return $#_
-                           ? $_[0]{$attribute} = $_[1]
-                           : $_[0]{$attribute};
-                  };
-
-               $metadata_for{$caller}{$attribute} = ();
-
-               if ( my $I = $args{isa} ) {
-                  my $orig_I = $I;
-                  my $type;
-                  if ( $I =~ /\A(ArrayRef|Maybe)\[(.*)\]\z/ ) {
-                     $I = _nested_constraints($attribute, $1, $2);
-                  }
-                  $metadata_for{$caller}{$attribute}{isa} = [$orig_I, $I];
-                  my $orig_method = $method;
-                  $method = sub {
-                     if ( $#_ ) {
-                        Mo::_check_type_constaints($attribute, $I, $orig_I, $_[1]);
-                     }
-                     goto &$orig_method;
-                  };
-               }
-
-               if ( my $builder = $args{builder} ) {
-                  my $original_method = $method;
-                  $method = sub {
-                        $#_
-                           ? goto &$original_method
-                           : ! exists $_[0]{$attribute}
-                              ? $_[0]{$attribute} = $_[0]->$builder
-                              : goto &$original_method
-                  };
-               }
-
-               if ( my $code = $args{default} ) {
-                  Carp::confess("${caller}::${attribute}'s default is $code, but should be a coderef")
-                        unless ref($code) eq 'CODE';
-                  my $original_method = $method;
-                  $method = sub {
-                        $#_
-                           ? goto &$original_method
-                           : ! exists $_[0]{$attribute}
-                              ? $_[0]{$attribute} = $_[0]->$code
-                              : goto &$original_method
-                  };
-               }
-
-               if ( my $role = $args{does} ) {
-                  my $original_method = $method;
-                  $method = sub {
-                     if ( $#_ ) {
-                        Carp::confess(qq<Attribute ($attribute) doesn't consume a '$role' role">)
-                           unless blessed($_[1]) && $_[1]->does($role)
-                     }
-                     goto &$original_method
-                  };
-               }
-
-               if ( my $coercion = $args{coerce} ) {
-                  $metadata_for{$caller}{$attribute}{coerce} = $coercion;
-                  my $original_method = $method;
-                  $method = sub {
-                     if ( $#_ ) {
-                        return $original_method->($_[0], $coercion->($_[1]))
-                     }
-                     goto &$original_method;
-                  }
-               }
-
-               $method = $options{$_}->($method, $attribute, @_)
-                  for sort keys %options;
-
-               *{ _glob_for "${caller}::$attribute" } = $method;
-
-               if ( $args{required} ) {
-                  $metadata_for{$caller}{$attribute}{required} = 1;
-               }
-
-               if ($args{clearer}) {
-                  *{ _glob_for "${caller}::$args{clearer}" }
-                     = sub { delete shift->{$attribute} }
-               }
-
-               if ($args{predicate}) {
-                  *{ _glob_for "${caller}::$args{predicate}" }
-                     = sub { exists shift->{$attribute} }
-               }
-
-               if ($args{handles}) {
-                  _has_handles($caller, $attribute, \%args);
-               }
-
-               if (exists $args{init_arg}) {
-                  $metadata_for{$caller}{$attribute}{init_arg} = $args{init_arg};
-               }
-            }
-        },
-        %exports,
-    );
-
-    $export_for{$caller} = [ keys %exports ];
-
-    for my $keyword ( keys %exports ) {
-      *{ _glob_for "${caller}::$keyword" } = $exports{$keyword}
-    }
-    *{ _glob_for "${caller}::extends" }{CODE}->( "Mo::Object" )
-      unless @{ *{ _glob_for "${caller}::ISA" }{ARRAY} || [] };
-};
-
-sub _check_type_constaints {
-   my ($attribute, $I, $I_name, $val) = @_;
-   ( ref($I) eq 'CODE'
-      ? $I->($val)
-      : (ref $val eq $I
-         || ($val && $val eq $I)
-         || (exists $TYPES{$I} && $TYPES{$I}->($val)))
-   )
-   || Carp::confess(
-         qq<Attribute ($attribute) does not pass the type constraint because: >
-      . qq<Validation failed for '$I_name' with value >
-      . (defined $val ? Mo::Dumper($val) : 'undef') )
-}
-
-sub _has_handles {
-   my ($caller, $attribute, $args) = @_;
-   my $handles = $args->{handles};
-
-   my $ref = ref $handles;
-   my $kv;
-   if ( $ref eq ref [] ) {
-         $kv = { map { $_,$_ } @{$handles} };
-   }
-   elsif ( $ref eq ref {} ) {
-         $kv = $handles;
-   }
-   elsif ( $ref eq ref qr// ) {
-         Carp::confess("Cannot delegate methods based on a Regexp without a type constraint (isa)")
-            unless $args->{isa};
-         my $target_class = $args->{isa};
-         $kv = {
-            map   { $_, $_     }
-            grep  { $_ =~ $handles }
-            grep  { !exists $Mo::Object::{$_} && $target_class->can($_) }
-            grep  { $_ ne 'has' && $_ ne 'extends' }
-            keys %{ _stash_for $target_class }
-         };
-   }
-   else {
-         Carp::confess("handles for $ref not yet implemented");
-   }
-
-   while ( my ($method, $target) = each %{$kv} ) {
-         my $name = _glob_for "${caller}::$method";
-         Carp::confess("You cannot overwrite a locally defined method ($method) with a delegation")
-            if defined &$name;
-
-         my ($target, @curried_args) = ref($target) ? @$target : $target;
-         *$name = sub {
-            my $self        = shift;
-            my $delegate_to = $self->$attribute();
-            my $error = "Cannot delegate $method to $target because the value of $attribute";
-            Carp::confess("$error is not defined") unless $delegate_to;
-            Carp::confess("$error is not an object (got '$delegate_to')")
-               unless Scalar::Util::blessed($delegate_to) || (!ref($delegate_to) && $delegate_to->can($target));
-            return $delegate_to->$target(@curried_args, @_);
-         }
-   }
-}
-
-sub _nested_constraints {
-   my ($attribute, $aggregate_type, $type) = @_;
-
-   my $inner_types;
-   if ( $type =~ /\A(ArrayRef|Maybe)\[(.*)\]\z/ ) {
-      $inner_types = _nested_constraints($1, $2);
-   }
-   else {
-      $inner_types = $TYPES{$type};
-   }
-
-   if ( $aggregate_type eq 'ArrayRef' ) {
-      return sub {
-         my ($val) = @_;
-         return unless ref($val) eq ref([]);
-
-         if ($inner_types) {
-            for my $value ( @{$val} ) {
-               return unless $inner_types->($value) 
-            }
-         }
-         else {
-            for my $value ( @{$val} ) {
-               return unless $value && ($value eq $type
-                        || (Scalar::Util::blessed($value) && $value->isa($type)));
-            }
-         }
-         return 1;
-      };
-   }
-   elsif ( $aggregate_type eq 'Maybe' ) {
-      return sub {
-         my ($value) = @_;
-         return 1 if ! defined($value);
-         if ($inner_types) {
-            return unless $inner_types->($value) 
-         }
-         else {
-            return unless $value eq $type
-                        || (Scalar::Util::blessed($value) && $value->isa($type));
-         }
-         return 1;
-      }
-   }
-   else {
-      Carp::confess("Nested aggregate types are only implemented for ArrayRefs and Maybe");
-   }
-}
-
-sub _set_package_isa {
-   my ($package, @new_isa) = @_;
-
-   *{ _glob_for "${package}::ISA" } = [@new_isa];
-}
-
-sub _set_inherited_metadata {
-   my $class = shift;
-   my $linearized_isa = mro::get_linear_isa($class);
-   my %new_metadata;
-
-   for my $isa_class (reverse @$linearized_isa) {
-      %new_metadata = (
-         %new_metadata,
-         %{ $metadata_for{$isa_class} || {} },
-      );
-   }
-   $metadata_for{$class} = \%new_metadata;
-}
-
-sub unimport {
-   my $caller = scalar caller();
-   my $stash  = _stash_for( $caller );
-
-   delete $stash->{$_} for @{$export_for{$caller}};
-}
-
-sub Dumper {
-   require Data::Dumper;
-   local $Data::Dumper::Indent    = 0;
-   local $Data::Dumper::Sortkeys  = 0;
-   local $Data::Dumper::Quotekeys = 0;
-   local $Data::Dumper::Terse     = 1;
-
-   Data::Dumper::Dumper(@_)
-}
-
-BEGIN {
-   if ($] >= 5.010) {
-      { local $@; require mro; }
-   }
-   else {
-      local $@;
-      eval {
-         require MRO::Compat;
-      } or do {
-         *mro::get_linear_isa = *mro::get_linear_isa_dfs = sub {
-            no strict 'refs';
-
-            my $classname = shift;
-
-            my @lin = ($classname);
-            my %stored;
-            foreach my $parent (@{"$classname\::ISA"}) {
-               my $plin = mro::get_linear_isa_dfs($parent);
-               foreach (@$plin) {
-                     next if exists $stored{$_};
-                     push(@lin, $_);
-                     $stored{$_} = 1;
-               }
-            }
-            return \@lin;
-         };
-      }
-   }
-}
-
-}
-1;
-}
-# ###########################################################################
-# End Mo package
-# ###########################################################################
-
 # ###########################################################################
 # DSNParser package
 # This package is a copy without comments from the original.  The original
@@ -2860,192 +2406,6 @@ sub deserialize_list {
 # End Quoter package
 # ###########################################################################
 
-# ###########################################################################
-# VersionParser package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/VersionParser.pm
-#   t/lib/VersionParser.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package VersionParser;
-
-use Mo;
-use Scalar::Util qw(blessed);
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use overload (
-   '""'     => "version",
-   '<=>'    => "cmp",
-   'cmp'    => "cmp",
-   fallback => 1,
-);
-
-our $VERSION = 0.01;
-
-has major => (
-    is       => 'ro',
-    isa      => 'Int',
-    required => 1,
-);
-
-has [qw( minor revision )] => (
-    is  => 'ro',
-    isa => 'Num',
-);
-
-has flavor => (
-    is      => 'ro',
-    isa     => 'Str',
-    default => sub { 'Unknown' },
-);
-
-has innodb_version => (
-    is      => 'ro',
-    isa     => 'Str',
-    default => sub { 'NO' },
-);
-
-sub series {
-   my $self = shift;
-   return $self->_join_version($self->major, $self->minor);
-}
-
-sub version {
-   my $self = shift;
-   return $self->_join_version($self->major, $self->minor, $self->revision);
-}
-
-sub is_in {
-   my ($self, $target) = @_;
-
-   return $self eq $target;
-}
-
-sub _join_version {
-    my ($self, @parts) = @_;
-
-    return join ".", map { my $c = $_; $c =~ s/^0\./0/; $c } grep defined, @parts;
-}
-sub _split_version {
-   my ($self, $str) = @_;
-   my @version_parts = map { s/^0(?=\d)/0./; $_ } $str =~ m/(\d+)/g;
-   return @version_parts[0..2];
-}
-
-sub normalized_version {
-   my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
-   my $result = sprintf('%d%02d%02d', @version_parts);
-   PTDEBUG && _d($self->version, 'normalizes to', $result);
-   return $result;
-}
-
-sub comment {
-   my ( $self, $cmd ) = @_;
-   my $v = $self->normalized_version();
-
-   return "/*!$v $cmd */"
-}
-
-my @methods = qw(major minor revision);
-sub cmp {
-   my ($left, $right) = @_;
-   my $right_obj = (blessed($right) && $right->isa(ref($left)))
-                   ? $right
-                   : ref($left)->new($right);
-
-   my $retval = 0;
-   for my $m ( @methods ) {
-      last unless defined($left->$m) && defined($right_obj->$m);
-      $retval = $left->$m <=> $right_obj->$m;
-      last if $retval;
-   }
-   return $retval;
-}
-
-sub BUILDARGS {
-   my $self = shift;
-
-   if ( @_ == 1 ) {
-      my %args;
-      if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
-         PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
-            @args{@methods} = $self->_split_version($query->{version});
-            $args{flavor} = delete $query->{version_comment}
-                  if $query->{version_comment};
-         }
-         elsif ( eval { ($query) = $dbh->selectrow_array('SELECT VERSION()') } ) {
-            @args{@methods} = $self->_split_version($query);
-         }
-         else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
-         }
-         $args{innodb_version} = eval { $self->_innodb_version($dbh) };
-      }
-      elsif ( !ref($_[0]) ) {
-         @args{@methods} = $self->_split_version($_[0]);
-      }
-
-      for my $method (@methods) {
-         delete $args{$method} unless defined $args{$method};
-      }
-      @_ = %args if %args;
-   }
-
-   return $self->SUPER::BUILDARGS(@_);
-}
-
-sub _innodb_version {
-   my ( $self, $dbh ) = @_;
-   return unless $dbh;
-   my $innodb_version = "NO";
-
-   my ($innodb) =
-      grep { $_->{engine} =~ m/InnoDB/i }
-      map  {
-         my %hash;
-         @hash{ map { lc $_ } keys %$_ } = values %$_;
-         \%hash;
-      }
-      @{ $dbh->selectall_arrayref("SHOW ENGINES", {Slice=>{}}) };
-   if ( $innodb ) {
-      PTDEBUG && _d("InnoDB support:", $innodb->{support});
-      if ( $innodb->{support} =~ m/YES|DEFAULT/i ) {
-         my $vars = $dbh->selectrow_hashref(
-            "SHOW VARIABLES LIKE 'innodb_version'");
-         $innodb_version = !$vars ? "BUILTIN"
-                         :          ($vars->{Value} || $vars->{value});
-      }
-      else {
-         $innodb_version = $innodb->{support};  # probably DISABLED or NO
-      }
-   }
-
-   PTDEBUG && _d("InnoDB version:", $innodb_version);
-   return $innodb_version;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-no Mo;
-1;
-}
-# ###########################################################################
-# End VersionParser package
-# ###########################################################################
-
 # ###########################################################################
 # TableParser package
 # This package is a copy without comments from the original.  The original

bin/pt-index-usage

@@ -3970,6 +3970,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -4024,8 +4026,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -4059,10 +4062,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -4071,7 +4077,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-kill

@@ -3096,10 +3096,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-online-schema-change

@@ -1506,6 +1506,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -1560,8 +1562,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -1595,10 +1598,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -1607,7 +1613,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }
@@ -3632,10 +3639,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-query-advisor

@@ -5495,7 +5495,7 @@ sub get_keys {
       my ( $type, $cols ) = $key =~ m/(?:USING (\w+))? \((.+)\)/;
       my ( $special ) = $key =~ m/(FULLTEXT|SPATIAL)/;
       $type = $type || $special || 'BTREE';
-      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '004001000'
+      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '4.1'
          && $engine =~ m/HEAP|MEMORY/i )
       {
          $type = 'HASH'; # MySQL pre-4.1 supports only HASH indexes on HEAP

bin/pt-query-digest

@@ -8296,7 +8296,7 @@ sub get_keys {
       my ( $type, $cols ) = $key =~ m/(?:USING (\w+))? \((.+)\)/;
       my ( $special ) = $key =~ m/(FULLTEXT|SPATIAL)/;
       $type = $type || $special || 'BTREE';
-      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '004001000'
+      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '4.1'
          && $engine =~ m/HEAP|MEMORY/i )
       {
          $type = 'HASH'; # MySQL pre-4.1 supports only HASH indexes on HEAP
@@ -10533,11 +10533,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   my $vp   = $self->{VersionParser};
-   if ( $vp && !$vp->version_ge($dbh, '4.1.2') ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-slave-find

@@ -2058,10 +2058,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 
@@ -2764,6 +2760,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -2818,8 +2816,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -2853,10 +2852,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -2865,7 +2867,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-slave-restart

@@ -1625,6 +1625,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -1679,8 +1681,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -1714,10 +1717,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -1726,7 +1732,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }
@@ -2363,10 +2370,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-table-checksum

@@ -2130,6 +2130,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -2184,8 +2186,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -2219,10 +2222,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -2231,7 +2237,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }
@@ -3216,10 +3223,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-table-sync

@@ -1986,6 +1986,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -2040,8 +2042,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -2075,10 +2078,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -2087,7 +2093,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }
@@ -6650,10 +6657,6 @@ sub get_connected_slaves {
 
    my $show = "SHOW GRANTS FOR ";
    my $user = 'CURRENT_USER()';
-   if ( VersionParser->new($dbh) < '4.1.2' ) {
-      $user = $dbh->selectrow_arrayref('SELECT USER()')->[0];
-      $user =~ s/([^@]+)@(.+)/'$1'\@'$2'/;
-   }
    my $sql = $show . $user;
    PTDEBUG && _d($dbh, $sql);
 

bin/pt-table-usage

@@ -5868,7 +5868,7 @@ sub get_keys {
       my ( $type, $cols ) = $key =~ m/(?:USING (\w+))? \((.+)\)/;
       my ( $special ) = $key =~ m/(FULLTEXT|SPATIAL)/;
       $type = $type || $special || 'BTREE';
-      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '004001000'
+      if ( $opts->{mysql_version} && $opts->{mysql_version} lt '4.1'
          && $engine =~ m/HEAP|MEMORY/i )
       {
          $type = 'HASH'; # MySQL pre-4.1 supports only HASH indexes on HEAP

bin/pt-upgrade

@@ -8583,6 +8583,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -8637,8 +8639,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -8672,10 +8675,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -8684,7 +8690,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }

bin/pt-variable-advisor

@@ -1867,6 +1867,8 @@ use overload (
    fallback => 1,
 );
 
+use Carp ();
+
 our $VERSION = 0.01;
 
 has major => (
@@ -1921,8 +1923,9 @@ sub _split_version {
 
 sub normalized_version {
    my ( $self ) = @_;
-   my @version_parts = map { $_ || 0 } $self->_split_version( $self->version );
+   my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major,
-   my $result = sprintf('%d%02d%02d', @version_parts);
+                                                      $self->minor,
+                                                      $self->revision);
    PTDEBUG && _d($self->version, 'normalizes to', $result);
    return $result;
 }
@@ -1956,10 +1959,13 @@ sub BUILDARGS {
    if ( @_ == 1 ) {
       my %args;
       if ( blessed($_[0]) && $_[0]->can("selectrow_hashref") ) {
-         my $dbh = $_[0];
-         my $query;
          PTDEBUG && _d("VersionParser got a dbh, trying to get the version");
-         if ( eval { $query = $dbh->selectall_hashref(q<SHOW VARIABLES LIKE 'version%'>) } ) {
+         my $dbh = $_[0];
+         my $query = eval {
+            $dbh->selectall_arrayref(q<SHOW VARIABLES LIKE 'version%'>, { Slice => {} })
+         };
+         if ( $query ) {
+            $query = { map { $_->{variable_name} => $_->{value} } @$query };
             @args{@methods} = $self->_split_version($query->{version});
             $args{flavor} = delete $query->{version_comment}
                   if $query->{version_comment};
@@ -1968,7 +1974,8 @@ sub BUILDARGS {
             @args{@methods} = $self->_split_version($query);
          }
          else {
-            PTDEBUG && _d("Couldn't get the version from the dbh: $@");
+            Carp::confess("Couldn't get the version from the dbh while "
+                        . "creating a VersionParser object: $@");
          }
          $args{innodb_version} = eval { $self->_innodb_version($dbh) };
       }