anchor.diff:  
      When RESULT-TYPE is list, the row is a list, when RESULT-TYPE is vector,
      the row passed to the FN function is a vector."
  -  (loop for row = (parse-resultset-row column-count
  -                                       column-definitions
  -                                       :as-text as-text
  -                                       :result-type result-type)
  -     until (typep row 'response-end-of-file-packet)
  -     do (funcall fn row)))
  +  (let ((parse-fun (if as-text
  +                       (ecase result-type
  +                         (list   #'parse-resultset-row-as-text-list)
  +                         (vector #'parse-resultset-row-as-text-vector))
  +                       (ecase result-type
  +                         (list   #'parse-resultset-row-as-list)
  +                         (vector #'parse-resultset-row-as-vector)))))
  +    (loop for row = (funcall parse-fun column-count column-definitions)
  +       until (typep row 'response-end-of-file-packet)
  +       do (funcall fn row))))
   
   (defun parse-resultset-rows (column-count column-definitions
                                &key as-text result-type)
     "Accumulate the whole result set in memory then return it as a list or a
      vector depending on the value of RESULT-TYPE (a symbol)."
  -  (let ((rows
  -         (loop for row = (parse-resultset-row column-count
  -                                              column-definitions
  -                                              :as-text as-text
  -                                              :result-type result-type)
  -            until (typep row 'response-end-of-file-packet)
  -            collect row)))
  +  (let* ((parse-fun (if as-text
  +                        (ecase result-type
  +                          (list   #'parse-resultset-row-as-text-list)
  +                          (vector #'parse-resultset-row-as-text-vector))
  +                        (ecase result-type
  +                          (list   #'parse-resultset-row-as-list)
  +                          (vector #'parse-resultset-row-as-vector))))
  +         (rows
  +          (loop for row = (funcall parse-fun column-count column-definitions)
  +             until (typep row 'response-end-of-file-packet)
  +             collect row)))
       (coerce rows result-type)))
   
   (defun decode-octets-to-string (octets &optional encoding)
  
positive.code: 
  (declaim (inline parse-text-protocol-result-column-as-text))
  
  (defun parse-resultset-row (column-count column-definitions
                              &key as-text result-type)
    "Parse a single row of the result set and return either a vector or a
     list, depending on the value of RESULT-TYPE.
  
     If AS-TEXT is t, return bare data from the server, still dealing with
     encoding of the text columns.
  
     The default for AS-TEXT is nil, in which case the result columns are
     parsed into native types depending on the meta data passed in
     COLUMNS-DEFINITIONS."
    (let* ((stream (mysql-read-packet))
           (tag    (peek-first-octet stream)))
      (labels
          ((parse-column (str column-definition)
             (when str
               (if as-text
                   (parse-text-protocol-result-column-as-text str column-definition)
                   (parse-text-protocol-result-column str column-definition))))
  
           (result-as-vector (stream)
             (let ((row (make-array column-count :initial-element nil)))
               (loop for i fixnum from 0 below column-count
                  for str = (read-length-encoded-octets stream :null-ok t)
                  when str
                  do (setf (aref row i)
                           (parse-column str (aref column-definitions i))))
               row))
  
           (result-as-list (stream)
             (loop for i fixnum from 0 below column-count
                for str = (read-length-encoded-octets stream :null-ok t)
                collect (parse-column str (aref column-definitions i)))))
  
        (declare (inline parse-column
                         result-as-vector
                         result-as-list))
        (cond
          ((or (and (= tag +mysql-response-end-of-file+)
                    (< (my-len stream) 9))
               (= tag +mysql-response-error+))
           (parse-response stream))
          (t
           (ecase result-type
             (vector  (result-as-vector stream))
             (list    (result-as-list stream))))))))
  
  (defun map-resultset-rows (fn column-count column-definitions
                             &key as-text result-type)
  
negative.code:   "Refrain from parsing data into lisp types, some application will only use
     the text form anyway"
    (let ((column-type (column-definition-type column-definition)))
      (case column-type
        (+mysql-type-null+
         nil)
        ((+mysql-type-string+
          +mysql-type-var-string+
          +mysql-type-tiny-blob+
          +mysql-type-medium-blob+
          +mysql-type-long-blob+
          +mysql-type-blob+)
         (if (= (column-definition-v41-packet-cs-coll column-definition)
                +mysql-cs-coll-binary+)
             octets
             (let ((encoding (column-definition-encoding column-definition)))
               (decode-octets-to-string octets encoding))))
        ((+mysql-type-bit+
          +mysql-type-enum+
          +mysql-type-set+
          +mysql-type-geometry+)
         octets)
        (otherwise
         (let ((encoding (column-definition-encoding column-definition)))
           (decode-octets-to-string octets encoding))))))
  
  (defun parse-text-protocol-result-column (octets column-definition)
    (let ((column-type (column-definition-type column-definition))
  