my $subfield_structure = $dbh->selectall_hashref( q|

    # We moved to selectall_arrayref since selectall_hashref does not

    # keep duplicate mappings on kohafield (like place in 260 vs 264)

    my $subfield_aref = $dbh->selectall_arrayref( q|

    |, 'kohafield', {}, $frameworkcode );

        ORDER BY frameworkcode,tagfield,tagsubfield

    |, { Slice => {} }, $frameworkcode );

    # Now map the output to a hash structure

    my $subfield_structure = {};

    foreach my $row ( @$subfield_aref ) {

        push @{ $subfield_structure->{ $row->{kohafield} }}, $row;

    }

    return ( $mss->{$kohafield}{tagfield}, $mss->{$kohafield}{tagsubfield} );

    my @retval;

    foreach( @{ $mss->{$kohafield} } ) {

        push @retval, $_->{tagfield}, $_->{tagsubfield};

    }

    return wantarray ? @retval : $retval[0];

    return exists $mss->{$kohafield}

    return unless $mss->{$kohafield};

        ? $mss->{$kohafield}

    return wantarray ? @{$mss->{$kohafield}} : $mss->{$kohafield}->[0];

        : undef;

    my $hash = shift;

    my ( $hash, $frameworkcode, $params ) = @_;

    # FIXME Do not we want to get the marc subfield structure for the biblio framework?

    # NOTE: Many older calls do not include a frameworkcode. In that case

    my $mss = GetMarcSubfieldStructure();

    # we default to Default framework.

    my $mss = GetMarcSubfieldStructure( $frameworkcode//'' );

        next unless exists $mss->{$kohafield};

        foreach my $fld ( @{ $mss->{$kohafield} } ) {

        next unless $mss->{$kohafield};

            my $tagfield    = $fld->{tagfield};

        my $tagfield    = $mss->{$kohafield}{tagfield} . '';

            my $tagsubfield = $fld->{tagsubfield};

        my $tagsubfield = $mss->{$kohafield}{tagsubfield};

            next if !$tagfield;

        foreach my $value ( split(/\s?\|\s?/, $value, -1) ) {

            my @values = $params->{no_split}

            next if $value eq '';

                ? ( $value )

            $tag_hr->{$tagfield} //= [];

                : split(/\s?\|\s?/, $value, -1);

            push @{$tag_hr->{$tagfield}}, [($tagsubfield, $value)];

            foreach my $value ( @values ) {

                next if $value eq '';

                $tag_hr->{$tagfield} //= [];

                push @{$tag_hr->{$tagfield}}, [($tagsubfield, $value)];

            }

    $frameworkcode = '' unless defined $frameworkcode;

    $frameworkcode //= '';

                    unless ( ( $key eq "biblionumber" or $key eq "biblioitemnumber" ) and ( $field->data() eq "" ) ) {

                    $result->{$key} .= " | " . $value

                        $result->{$key} .= " | " . $field->data();

                        unless $result->{$key} eq $value;

                    }

                    $result->{$key} = $field->data();

                    $result->{$key} = $value;

                        unless ( ( $key eq "biblionumber" or $key eq "biblioitemnumber" ) and ( $value eq "" ) ) {

                        $result->{$key} .= " | " . $value

                            $result->{$key} .= " | " . $value;

                            unless $result->{$key} eq $value;

                        }

        next unless exists $mss->{$kohafield};    # not all columns are mapped to MARC tag & subfield

        foreach my $fld ( @{ $mss->{$kohafield} } ) {

        my $tag      = $mss->{$kohafield}{tagfield};

            my $tag = $fld->{tagfield};

        my $subfield = $mss->{$kohafield}{tagsubfield};

            my $subfield = $fld->{tagsubfield};

        my ( $table, $column ) = split /[.]/, $kohafield, 2;

            my ( $table, $column ) = split /[.]/, $kohafield, 2;

        push @{ $field_map->{$tag}->{list} }, [ $subfield, $table, $column ];

            push @{ $field_map->{$tag}->{list} },

        push @{ $field_map->{$tag}->{sfs}->{$subfield} }, [ $table, $column ];

                [ $subfield, $table, $column ];

            push @{ $field_map->{$tag}->{sfs}->{$subfield} },

                [ $table, $column ];

        }

  $result = TransformMarcToKohaOneField( $kohatable, $kohafield, $record, $result, $frameworkcode )

    $value = TransformMarcToKohaOneField( 'biblio.title', $record, $frameworkcode );

    my ( $kohafield, $marc, $frameworkcode ) = @_;

    # FIXME ? if a field has a repeatable subfield that is used in old-db,

    # only the 1st will be retrieved...

    # It is not really useful to repeat all code from TransformMarcToKoha here.

    my ( $kohatable, $kohafield, $record, $result, $frameworkcode ) = @_;

    # Since it is fast enough (by caching), we just extract the field.

    my $res = "";

    my $koharec = TransformMarcToKoha( $marc, $frameworkcode );

    my ( $tagfield, $subfield ) = GetMarcFromKohaField( $kohatable . "." . $kohafield, $frameworkcode );

    my @temp = split /\./, $kohafield, 2;

    foreach my $field ( $record->field($tagfield) ) {

    $kohafield = _disambiguate( @temp ) if @temp > 1;

        if ( $field->tag() < 10 ) {

    return $koharec ? $koharec->{$kohafield} : undef;

            if ( $result->{$kohafield} ) {

                $result->{$kohafield} .= " | " . $field->data();

            } else {

                $result->{$kohafield} = $field->data();

            }

        } else {

            if ( $field->subfields ) {

                my @subfields = $field->subfields();

                foreach my $subfieldcount ( 0 .. $#subfields ) {

                    if ( $subfields[$subfieldcount][0] eq $subfield ) {

                        if ( $result->{$kohafield} ) {

                            $result->{$kohafield} .= " | " . $subfields[$subfieldcount][1];

                        } else {

                            $result->{$kohafield} = $subfields[$subfieldcount][1];

                        }

                    }

                }

            }

        }

    }

    return $result;

        my ($t, $f)= split '\.', $fetch{$k};

        $row->{$k} = C4::Biblio::TransformMarcToKohaOneField( $fetch{$k}, $record, q{} ); # default framework

        $row= C4::Biblio::TransformMarcToKohaOneField($t, $f, $record, $row);

        $row->{$k}= $row->{$f} if $k ne $f;

    my $itemmarc = TransformKohaToMarc($mungeditem);

    my $framework = GetFrameworkCode( $biblionumber );

    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",GetFrameworkCode($biblionumber)||'');

    my $itemmarc = TransformKohaToMarc(

        $mungeditem, $framework, { no_split => 1},

    );

    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField(

        "items.itemnumber", $framework,

    );

    my $biblionumber = C4::Biblio::get_koha_field_from_marc('biblio', 'biblionumber', $record, '');

    my $biblionumber = C4::Biblio::TransformMarcToKohaOneField(

        'biblio.biblionumber', $record, # Default framework used

    );

        my $frameworkcode = ""; # FIXME Why do we use the default framework?

        return C4::Biblio::TransformMarcToKohaOneField($kohafield, $self->record); # Default framework used

        my $mss = C4::Biblio::GetMarcSubfieldStructure( $frameworkcode );

        my $tagfield = $mss->{$kohafield};

        return '' if ref($tagfield) ne 'HASH';

        my ($tag, $subfield) = ( $tagfield->{tagfield}, $tagfield->{tagsubfield} );

        my @kohafield;

        foreach my $field ( $self->record->field($tag) ) {

            if ( $field->tag() < 10 ) {

                push @kohafield, $field->data();

            } else {

                foreach my $contents ( $field->subfield($subfield) ) {

                    push @kohafield, $contents;

                }

            }

        }

        return join ' | ', @kohafield;