Well how about them apples?! Add temporary overload-madness escape hatch

[dbsrgits/SQL-Abstract.git] / lib / SQL / Abstract.pm

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index 54408df..08f6011 100644 (file)
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -16,6 +16,11 @@ BEGIN {
   else {
     require mro;
   }
+
+  *SQL::Abstract::_ENV_::DETECT_AUTOGENERATED_STRINGIFICATION = $ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION}
+    ? sub () { 0 }
+    : sub () { 1 }
+  ;
 }
 
 #======================================================================
@@ -84,47 +89,51 @@ sub is_literal_value ($) {
 # FIXME XSify - this can be done so much more efficiently
 sub is_plain_value ($) {
   no strict 'refs';
-    ! length ref $_[0]                                        ? [ $_[0] ]
+    ! length ref $_[0]                                        ? \($_[0])
   : (
     ref $_[0] eq 'HASH' and keys %{$_[0]} == 1
       and
     exists $_[0]->{-value}
-  )                                                           ? [ $_[0]->{-value} ]
+  )                                                           ? \($_[0]->{-value})
   : (
-      Scalar::Util::blessed $_[0]
+      # reuse @_ for even moar speedz
+      defined ( $_[1] = Scalar::Util::blessed $_[0] )
         and
       # deliberately not using Devel::OverloadInfo - the checks we are
       # intersted in are much more limited than the fullblown thing, and
       # this is a very hot piece of code
       (
-        # FIXME - DBI needs fixing to stringify regardless of DBD
-        #
         # simply using ->can('(""') can leave behind stub methods that
         # break actually using the overload later (see L<perldiag/Stub
         # found while resolving method "%s" overloading "%s" in package
         # "%s"> and the source of overload::mycan())
         #
         # either has stringification which DBI SHOULD prefer out of the box
-        grep { *{ (qq[${_}::(""]) }{CODE} } @{ mro::get_linear_isa( ref $_[0] ) }
+        grep { *{ (qq[${_}::(""]) }{CODE} } @{ $_[2] = mro::get_linear_isa( $_[1] ) }
           or
-        # has nummification and fallback is *not* disabled
-        # reuse @_ for even moar speedz
+        # has nummification or boolification, AND fallback is *not* disabled
         (
-          grep { *{"${_}::(0+"}{CODE} } @{ mro::get_linear_isa( ref $_[0] ) }
+          SQL::Abstract::_ENV_::DETECT_AUTOGENERATED_STRINGIFICATION
+            and
+          (
+            grep { *{"${_}::(0+"}{CODE} } @{$_[2]}
+              or
+            grep { *{"${_}::(bool"}{CODE} } @{$_[2]}
+          )
             and
           (
             # no fallback specified at all
-            ! ( ($_[1]) = grep { *{"${_}::()"}{CODE} } @{ mro::get_linear_isa( ref $_[0] ) } )
+            ! ( ($_[3]) = grep { *{"${_}::()"}{CODE} } @{$_[2]} )
               or
             # fallback explicitly undef
-            ! defined ${"$_[1]::()"}
+            ! defined ${"$_[3]::()"}
               or
             # explicitly true
-            ${"$_[1]::()"}
+            !! ${"$_[3]::()"}
           )
         )
       )
-    )                                                          ? [ "$_[0]" ]
+    )                                                          ? \($_[0])
   : undef;
 }
 
@@ -2148,9 +2157,50 @@ module:
 
 =back
 
-On failure returns C<undef>, on sucess returns a reference to a single
-element array containing the string-version of the supplied argument or
-C<[ undef ]> in case of an undefined initial argument.
+On failure returns C<undef>, on sucess returns a B<scalar> reference
+to the original supplied argument.
+
+=over
+
+=item * Note
+
+The stringification overloading detection is rather advanced: it takes
+into consideration not only the presence of a C<""> overload, but if that
+fails also checks for enabled
+L<autogenerated versions of C<"">|overload/Magic Autogeneration>, based
+on either C<0+> or C<bool>.
+
+Unfortunately testing in the field indicates that this
+detection B<< may tickle a latent bug in perl versions before 5.018 >>,
+but only when very large numbers of stringifying objects are involved.
+At the time of writing ( Sep 2014 ) there is no clear explanation of
+the direct cause, nor is there a manageably small test case that reliably
+reproduces the problem.
+
+If you encounter any of the following exceptions in B<random places within
+your application stack> - this module may be to blame:
+
+  Operation "ne": no method found,
+    left argument in overloaded package <something>,
+    right argument in overloaded package <something>
+
+or perhaps even
+
+  Stub found while resolving method "???" overloading """" in package <something>
+
+If you fall victim to the above - please attempt to reduce the problem
+to something that could be sent to the L<SQL::Abstract developers
+|DBIx::Class/GETTING_HELP/SUPPORT>
+(either publicly or privately). As a workaround in the meantime you can
+set C<$ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION}> to a true
+value, which will most likely eliminate your problem (at the expense of
+not being able to properly detect exotic forms of stringification).
+
+This notice and environment variable will be removed in a future version,
+as soon as the underlying problem is found and a reliable workaround is
+devised.
+
+=back
 
 =head2 is_literal_value
 
@@ -2167,8 +2217,8 @@ module:
 
 =back
 
-On failure returns C<undef>, on sucess returns a reference to an array
-cotaining the unpacked version of the supplied literal SQL and bind values.
+On failure returns C<undef>, on sucess returns an B<array> reference
+containing the unpacked version of the supplied literal SQL and bind values.
 
 =head1 WHERE CLAUSES