From 541d001d2a7208e30fcb4ee594d05c9e6aacbd06 Mon Sep 17 00:00:00 2001 From: Brian Fraser Date: Fri, 13 Jul 2012 01:25:31 -0300 Subject: [PATCH] Updated modules --- bin/pt-archiver | 23 +- bin/pt-deadlock-logger | 19 +- bin/pt-duplicate-key-checker | 19 +- bin/pt-find | 19 +- bin/pt-heartbeat | 640 ----------------------------------- bin/pt-index-usage | 19 +- bin/pt-kill | 4 - bin/pt-online-schema-change | 23 +- bin/pt-query-advisor | 2 +- bin/pt-query-digest | 7 +- bin/pt-slave-find | 23 +- bin/pt-slave-restart | 23 +- bin/pt-table-checksum | 23 +- bin/pt-table-sync | 23 +- bin/pt-table-usage | 2 +- bin/pt-upgrade | 19 +- bin/pt-variable-advisor | 19 +- 17 files changed, 159 insertions(+), 748 deletions(-) diff --git a/bin/pt-archiver b/bin/pt-archiver index 548bcd39..3bade8ee 100755 --- a/bin/pt-archiver +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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); diff --git a/bin/pt-deadlock-logger b/bin/pt-deadlock-logger index c2017a2f..7c6cc4e7 100755 --- a/bin/pt-deadlock-logger +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-duplicate-key-checker b/bin/pt-duplicate-key-checker index 753703be..720b7652 100755 --- a/bin/pt-duplicate-key-checker +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-find b/bin/pt-find index a12527b6..d083d7db 100755 --- a/bin/pt-find +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-heartbeat b/bin/pt-heartbeat index b3a17667..442b326b 100755 --- a/bin/pt-heartbeat +++ b/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) - 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 - . qq - . (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) } ) { - @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 diff --git a/bin/pt-index-usage b/bin/pt-index-usage index 07a23fdf..31dfa4f4 100755 --- a/bin/pt-index-usage +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-kill b/bin/pt-kill index d2aca332..63b0abd4 100755 --- a/bin/pt-kill +++ b/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); diff --git a/bin/pt-online-schema-change b/bin/pt-online-schema-change index 94ce1329..dd7a4b07 100755 --- a/bin/pt-online-schema-change +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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); diff --git a/bin/pt-query-advisor b/bin/pt-query-advisor index 71d479b4..721606f9 100755 --- a/bin/pt-query-advisor +++ b/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 diff --git a/bin/pt-query-digest b/bin/pt-query-digest index 6afdb8b2..688c8ecf 100755 --- a/bin/pt-query-digest +++ b/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); diff --git a/bin/pt-slave-find b/bin/pt-slave-find index 4fe482ee..aa60cd5d 100755 --- a/bin/pt-slave-find +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-slave-restart b/bin/pt-slave-restart index 7b897e51..1047c32d 100755 --- a/bin/pt-slave-restart +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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); diff --git a/bin/pt-table-checksum b/bin/pt-table-checksum index eceaf5d1..db2300da 100755 --- a/bin/pt-table-checksum +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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); diff --git a/bin/pt-table-sync b/bin/pt-table-sync index cc7e013b..6038ea51 100755 --- a/bin/pt-table-sync +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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); diff --git a/bin/pt-table-usage b/bin/pt-table-usage index 121cd1e8..5204edad 100755 --- a/bin/pt-table-usage +++ b/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 diff --git a/bin/pt-upgrade b/bin/pt-upgrade index b1cb2986..f87ea877 100755 --- a/bin/pt-upgrade +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; } diff --git a/bin/pt-variable-advisor b/bin/pt-variable-advisor index 270b6c28..d1de38b2 100755 --- a/bin/pt-variable-advisor +++ b/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', @version_parts); + my $result = sprintf('%d%02d%02d', map { $_ || 0 } $self->major, + $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) } ) { + my $dbh = $_[0]; + my $query = eval { + $dbh->selectall_arrayref(q, { 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) }; }