0 THEN my_using := ' USING (record)'; my_join := 'FULL OUTER JOIN'; ELSE my_using := ''; my_join := 'FROM'; END IF; IF node.tag IS NOT NULL THEN caseless := (node.tag IN ('020', '022', '024')); tagkey := node.tag; IF node.subfield IS NOT NULL THEN tagkey := tagkey || node.subfield; END IF; END IF; IF node.negate THEN IF caseless THEN op := 'NOT LIKE'; ELSE op := '<>'; END IF; ELSE IF caseless THEN op := 'LIKE'; ELSE op := '='; END IF; END IF; my_alias := 'n' || node.id::TEXT; jrow := my_join || ' (SELECT *, '; IF node.tag IS NOT NULL THEN jrow := jrow || node.quality || ' AS quality FROM ' || rec_table || ' mfr WHERE mfr.tag = ''' || node.tag || ''''; IF node.subfield IS NOT NULL THEN jrow := jrow || ' AND mfr.subfield = ''' || node.subfield || ''''; END IF; jrow := jrow || ' AND ('; jrow := jrow || vandelay._node_tag_comparisons(caseless, op, tags_rstore, tagkey); jrow := jrow || ')) ' || my_alias || my_using || E'\n'; ELSE -- svf IF auth_heading IS NOT NULL THEN -- authority record IF node.heading AND auth_heading <> '' THEN jrow := jrow || 'id AS record, ' || node.quality || ' AS quality FROM authority.record_entry are ' || ' WHERE are.heading = ''' || auth_heading || ''''; jrow := jrow || ') ' || my_alias || my_using || E'\n'; END IF; ELSE -- bib record jrow := jrow || 'id AS record, ' || node.quality || ' AS quality FROM metabib.record_attr_flat mraf WHERE mraf.attr = ''' || node.svf || ''' AND mraf.value ' || op || ' $2->''' || node.svf || ''') ' || my_alias || my_using || E'\n'; END IF; END IF; INSERT INTO _vandelay_tmp_jrows (j) VALUES (jrow); END;]]> tagkey; result := ''; WHILE TRUE LOOP IF i > 1 THEN IF vals[i] IS NULL THEN EXIT; ELSE result := result || ' OR '; END IF; END IF; IF caseless THEN result := result || 'LOWER(mfr.value) ' || op; ELSE result := result || 'mfr.value ' || op; END IF; result := result || ' ' || COALESCE('''' || vals[i] || '''', 'NULL'); IF vals[i] IS NULL THEN EXIT; END IF; i := i + 1; END LOOP; RETURN result; END;]]> 'UTF-8'); use MARC::Charset; use strict; MARC::Charset->assume_unicode(1); my $target_xml = shift; my $source_xml = shift; my $field_spec = shift; my $force_add = shift || 0; my $target_r = MARC::Record->new_from_xml( $target_xml ); my $source_r = MARC::Record->new_from_xml( $source_xml ); return $target_xml unless ($target_r && $source_r); my @field_list = split(',', $field_spec); my %fields; for my $f (@field_list) { $f =~ s/^\s*//; $f =~ s/\s*$//; if ($f =~ /^(.{3})(\w*)(?:\[([^]]*)\])?$/) { my $field = $1; $field =~ s/\s+//; my $sf = $2; $sf =~ s/\s+//; my $match = $3; $match =~ s/^\s*//; $match =~ s/\s*$//; $fields{$field} = { sf => [ split('', $sf) ] }; if ($match) { my ($msf,$mre) = split('~', $match); if (length($msf) > 0 and length($mre) > 0) { $msf =~ s/^\s*//; $msf =~ s/\s*$//; $mre =~ s/^\s*//; $mre =~ s/\s*$//; $fields{$field}{match} = { sf => $msf, re => qr/$mre/ }; } } } } for my $f ( keys %fields) { if ( @{$fields{$f}{sf}} ) { for my $from_field ($source_r->field( $f )) { my @tos = $target_r->field( $f ); if (!@tos) { next if (exists($fields{$f}{match}) and !$force_add); my @new_fields = map { $_->clone } $source_r->field( $f ); $target_r->insert_fields_ordered( @new_fields ); } else { for my $to_field (@tos) { if (exists($fields{$f}{match})) { next unless (grep { $_ =~ $fields{$f}{match}{re} } $to_field->subfield($fields{$f}{match}{sf})); } for my $old_sf ($from_field->subfields) { $to_field->add_subfields( @$old_sf ) if grep(/$$old_sf[0]/,@{$fields{$f}{sf}}); } } } } } else { my @new_fields = map { $_->clone } $source_r->field( $f ); $target_r->insert_fields_ordered( @new_fields ); } } $target_xml = $target_r->as_xml_record; $target_xml =~ s/^<\?.+?\?>$//mo; $target_xml =~ s/\n//sgo; $target_xml =~ s/>\s+ 1 THEN -- RAISE NOTICE 'not an exact match'; RETURN FALSE; END IF; SELECT m.eg_record INTO eg_id FROM vandelay.authority_match m WHERE m.queued_record = import_id LIMIT 1; IF eg_id IS NULL THEN RETURN FALSE; END IF; RETURN vandelay.overlay_authority_record( import_id, eg_id, merge_profile_id ); END;]]> = lwm_ratio_value ORDER BY m.match_score DESC, -- required match score qr.quality::NUMERIC / COALESCE(NULLIF(m.quality,0),1)::NUMERIC DESC, -- quality tie breaker m.id -- when in doubt, use the first match LIMIT 1; IF eg_id IS NULL THEN -- RAISE NOTICE 'incoming record is not of high enough quality'; RETURN FALSE; END IF; RETURN vandelay.overlay_authority_record( import_id, eg_id, merge_profile_id ); END;]]> 1 THEN -- RAISE NOTICE 'not an exact match'; RETURN FALSE; END IF; -- Check that the one match is on the first 901c SELECT m.eg_record INTO eg_id FROM vandelay.queued_bib_record q JOIN vandelay.bib_match m ON (m.queued_record = q.id) WHERE q.id = import_id AND m.eg_record = oils_xpath_string('//*[@tag="901"]/*[@code="c"][1]',marc)::BIGINT; IF NOT FOUND THEN -- RAISE NOTICE 'not a 901c match'; RETURN FALSE; END IF; RETURN vandelay.overlay_bib_record( import_id, eg_id, merge_profile_id ); END;]]> = lwm_ratio_value ORDER BY m.match_score DESC, -- required match score qr.quality::NUMERIC / COALESCE(NULLIF(m.quality,0),1)::NUMERIC DESC, -- quality tie breaker m.id -- when in doubt, use the first match LIMIT 1; IF eg_id IS NULL THEN -- RAISE NOTICE 'incoming record is not of high enough quality'; RETURN FALSE; END IF; RETURN vandelay.overlay_bib_record( import_id, eg_id, merge_profile_id ); END;]]> 0 LOOP FOR scope_org IN SELECT * FROM UNNEST(scope_orgs) LOOP -- For each match, get a count of all copies at descendants of our scope org. FOR rec IN SELECT * FROM vandelay.bib_match AS vbm WHERE queued_record = import_id ORDER BY vbm.eg_record DESC LOOP SELECT COUNT(acp.id) INTO copy_count FROM asset.copy AS acp INNER JOIN asset.call_number AS acn ON acp.call_number = acn.id WHERE acn.owning_lib IN (SELECT id FROM actor.org_unit_descendants(scope_org)) AND acn.record = rec.eg_record AND acp.deleted = FALSE; IF copy_count > max_copy_count THEN max_copy_count := copy_count; eg_id := rec.eg_record; END IF; END LOOP; END LOOP; -- If no matching bibs had holdings, gather our next set of orgs to check, and iterate. IF max_copy_count = 0 THEN SELECT ARRAY_AGG(DISTINCT parent_ou) INTO scope_orgs FROM actor.org_unit WHERE id IN (SELECT * FROM UNNEST(scope_orgs)) AND parent_ou IS NOT NULL; END IF; END LOOP; IF eg_id IS NULL THEN -- Could not determine best match via copy count -- fall back to default best match IF (SELECT * FROM vandelay.auto_overlay_bib_record_with_best( import_id, merge_profile_id, lwm_ratio_value_p )) THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END IF; RETURN vandelay.overlay_bib_record( import_id, eg_id, merge_profile_id ); END;]]> '' AND profile_tmpl_owner IS NOT NULL AND profile_tmpl_owner <> '' THEN SELECT p.* INTO profile FROM vandelay.merge_profile p JOIN actor.org_unit u ON (u.id = p.owner) WHERE p.name = profile_tmpl AND u.shortname = profile_tmpl_owner; IF profile.id IS NOT NULL THEN add_rule := COALESCE(profile.add_spec,''); strip_rule := COALESCE(profile.strip_spec,''); replace_rule := COALESCE(profile.replace_spec,''); preserve_rule := COALESCE(profile.preserve_spec,''); END IF; END IF; add_rule := add_rule || ',' || COALESCE(ARRAY_TO_STRING(oils_xpath('//*[@tag="905"]/*[@code="a"]/text()',incoming_xml),','),''); strip_rule := strip_rule || ',' || COALESCE(ARRAY_TO_STRING(oils_xpath('//*[@tag="905"]/*[@code="d"]/text()',incoming_xml),','),''); replace_rule := replace_rule || ',' || COALESCE(ARRAY_TO_STRING(oils_xpath('//*[@tag="905"]/*[@code="r"]/text()',incoming_xml),','),''); preserve_rule := preserve_rule || ',' || COALESCE(ARRAY_TO_STRING(oils_xpath('//*[@tag="905"]/*[@code="p"]/text()',incoming_xml),','),''); output.add_rule := BTRIM(add_rule,','); output.replace_rule := BTRIM(replace_rule,','); output.strip_rule := BTRIM(strip_rule,','); output.preserve_rule := BTRIM(preserve_rule,','); RETURN output; END;]]> 0 ELSE TRUE END GROUP BY x.tag ORDER BY x.tag LIMIT 1; ELSIF attr_def.fixed_field IS NOT NULL THEN -- a named fixed field, see config.marc21_ff_pos_map.fixed_field attr_value := vandelay.marc21_extract_fixed_field(xml, attr_def.fixed_field); ELSIF attr_def.xpath IS NOT NULL THEN -- and xpath expression SELECT INTO xfrm * FROM config.xml_transform WHERE name = attr_def.format; -- See if we can skip the XSLT ... it's expensive IF prev_xfrm IS NULL OR prev_xfrm <> xfrm.name THEN -- Can't skip the transform IF xfrm.xslt <> '---' THEN transformed_xml := oils_xslt_process(xml,xfrm.xslt); ELSE transformed_xml := xml; END IF; prev_xfrm := xfrm.name; END IF; IF xfrm.name IS NULL THEN -- just grab the marcxml (empty) transform SELECT INTO xfrm * FROM config.xml_transform WHERE xslt = '---' LIMIT 1; prev_xfrm := xfrm.name; END IF; attr_value := oils_xpath_string(attr_def.xpath, transformed_xml, COALESCE(attr_def.joiner,' '), ARRAY[ARRAY[xfrm.prefix, xfrm.namespace_uri]]); ELSIF attr_def.phys_char_sf IS NOT NULL THEN -- a named Physical Characteristic, see config.marc21_physical_characteristic_*_map SELECT m.value::TEXT INTO attr_value FROM vandelay.marc21_physical_characteristics(xml) v JOIN config.marc21_physical_characteristic_value_map m ON (m.id = v.value) WHERE v.subfield = attr_def.phys_char_sf LIMIT 1; -- Just in case ... END IF; -- apply index normalizers to attr_value FOR normalizer IN SELECT n.func AS func, n.param_count AS param_count, m.params AS params FROM config.index_normalizer n JOIN config.record_attr_index_norm_map m ON (m.norm = n.id) WHERE attr = attr_def.name ORDER BY m.pos LOOP EXECUTE 'SELECT ' || normalizer.func || '(' || quote_nullable( attr_value ) || CASE WHEN normalizer.param_count > 0 THEN ',' || REPLACE(REPLACE(BTRIM(normalizer.params,'[]'),E'\'',E'\\\''),E'"',E'\'') ELSE '' END || ')' INTO attr_value; END LOOP; -- Add the new value to the hstore new_attrs := new_attrs || hstore( attr_def.name, attr_value ); END LOOP; RETURN new_attrs; END;]]> '' THEN eg_tcn_source := BTRIM((oils_xpath('//*[@tag="003"]/text()',xml))[1]); IF eg_tcn_source IS NULL OR eg_tcn_source = '' THEN eg_tcn_source := 'System Local'; END IF; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 901 ab eg_tcn := BTRIM((oils_xpath('//*[@tag="901"]/*[@code="a"]/text()',xml))[1]); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := BTRIM((oils_xpath('//*[@tag="901"]/*[@code="b"]/text()',xml))[1]); IF eg_tcn_source IS NULL OR eg_tcn_source = '' THEN eg_tcn_source := 'System Local'; END IF; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 039 ab eg_tcn := BTRIM((oils_xpath('//*[@tag="039"]/*[@code="a"]/text()',xml))[1]); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := BTRIM((oils_xpath('//*[@tag="039"]/*[@code="b"]/text()',xml))[1]); IF eg_tcn_source IS NULL OR eg_tcn_source = '' THEN eg_tcn_source := 'System Local'; END IF; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 020 a eg_tcn := REGEXP_REPLACE((oils_xpath('//*[@tag="020"]/*[@code="a"]/text()',xml))[1], $re$^(\w+).*?$$re$, $re$\1$re$); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := 'ISBN'; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 022 a eg_tcn := REGEXP_REPLACE((oils_xpath('//*[@tag="022"]/*[@code="a"]/text()',xml))[1], $re$^(\w+).*?$$re$, $re$\1$re$); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := 'ISSN'; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 010 a eg_tcn := REGEXP_REPLACE((oils_xpath('//*[@tag="010"]/*[@code="a"]/text()',xml))[1], $re$^(\w+).*?$$re$, $re$\1$re$); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := 'LCCN'; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; -- 035 a eg_tcn := REGEXP_REPLACE((oils_xpath('//*[@tag="035"]/*[@code="a"]/text()',xml))[1], $re$^.*?(\w+)$$re$, $re$\1$re$); IF eg_tcn IS NOT NULL AND eg_tcn <> '' THEN eg_tcn_source := 'System Legacy'; PERFORM id FROM biblio.record_entry WHERE tcn_value = eg_tcn AND NOT deleted; IF NOT FOUND THEN output.used := FALSE; ELSE output.used := TRUE; END IF; output.tcn := eg_tcn; output.tcn_source := eg_tcn_source; RETURN NEXT output; END IF; RETURN; END;]]> 'UTF-8'); use MARC::Charset; use strict; MARC::Charset->assume_unicode(1); my $xml = shift; my $r = MARC::Record->new_from_xml( $xml ); return_next( { tag => 'LDR', value => $r->leader } ); for my $f ( $r->fields ) { if ($f->is_control_field) { return_next({ tag => $f->tag, value => $f->data }); } else { for my $s ($f->subfields) { return_next({ tag => $f->tag, ind1 => $f->indicator(1), ind2 => $f->indicator(2), subfield => $s->[0], value => $s->[1] }); if ( $f->tag eq '245' and $s->[0] eq 'a' ) { my $trim = $f->indicator(2) || 0; return_next({ tag => 'tnf', ind1 => $f->indicator(1), ind2 => $f->indicator(2), subfield => 'a', value => substr( $s->[1], $trim ) }); } } } } return undef;]]> 0 THEN this_op := vandelay._get_expr_render_one(node); q := '('; i := 1; WHILE children[i] IS NOT NULL LOOP SELECT * INTO child FROM vandelay.match_set_point WHERE id = children[i]; IF i > 1 THEN q := q || ' ' || this_op || ' '; END IF; i := i + 1; q := q || vandelay.get_expr_from_match_set_point( child, tags_rstore, auth_heading); END LOOP; q := q || ')'; RETURN q; ELSIF node.bool_op IS NULL THEN PERFORM vandelay._get_expr_push_qrow(node); PERFORM vandelay._get_expr_push_jrow(node, tags_rstore, auth_heading); RETURN vandelay._get_expr_render_one(node); ELSE RETURN ''; END IF; END;]]> '') THEN INSERT INTO vandelay.queued_authority_record_attr (record, field, attr_value) VALUES (NEW.id, adef.id, value); END IF; END LOOP; RETURN NULL; END;]]> '') THEN INSERT INTO vandelay.queued_bib_record_attr (record, field, attr_value) VALUES (NEW.id, adef.id, value); END IF; END LOOP; RETURN NULL; END;]]> 0; val := REPEAT( ff_pos.default_val, ff_pos.length ); collection := collection || val; END LOOP; RETURN collection; END;]]> '' THEN SELECT * INTO ptype FROM config.marc21_physical_characteristic_type_map WHERE ptype_key = SUBSTRING( _007, 1, 1 ); IF ptype.ptype_key IS NOT NULL THEN FOR psf IN SELECT * FROM config.marc21_physical_characteristic_subfield_map WHERE ptype_key = ptype.ptype_key LOOP SELECT * INTO pval FROM config.marc21_physical_characteristic_value_map WHERE ptype_subfield = psf.id AND value = SUBSTRING( _007, psf.start_pos + 1, psf.length ); IF pval.id IS NOT NULL THEN rowid := rowid + 1; retval.id := rowid; retval.ptype := ptype.ptype_key; retval.subfield := psf.id; retval.value := pval.id; RETURN NEXT retval; END IF; END LOOP; END IF; END IF; END LOOP; RETURN; END;]]> test.svf THEN out_q := out_q + test.quality; END IF; END IF; END LOOP; RETURN out_q; END;]]> '' AND dyn_profile.preserve_rule <> '' THEN -- RAISE NOTICE 'both replace [%] and preserve [%] specified', dyn_profile.replace_rule, dyn_profile.preserve_rule; RETURN NULL; END IF; IF dyn_profile.replace_rule = '' AND dyn_profile.preserve_rule = '' AND dyn_profile.add_rule = '' AND dyn_profile.strip_rule = '' THEN --Since we have nothing to do, just return what we were given. RETURN target_marc; ELSIF dyn_profile.replace_rule <> '' THEN trgt_marc = target_marc; tmpl_marc = template_marc; replace_rule = dyn_profile.replace_rule; ELSE tmp_marc = target_marc; trgt_marc = template_marc; tmpl_marc = tmp_marc; replace_rule = dyn_profile.preserve_rule; END IF; RETURN vandelay.merge_record_xml( trgt_marc, tmpl_marc, dyn_profile.add_rule, replace_rule, dyn_profile.strip_rule ); END;]]> '' AND dyn_profile.preserve_rule <> '' THEN -- RAISE NOTICE 'both replace [%] and preserve [%] specified', dyn_profile.replace_rule, dyn_profile.preserve_rule; RETURN NULL; END IF; IF dyn_profile.replace_rule = '' AND dyn_profile.preserve_rule = '' AND dyn_profile.add_rule = '' AND dyn_profile.strip_rule = '' THEN -- Since we have nothing to do, just return a target record as is RETURN existing_marc; ELSIF dyn_profile.preserve_rule <> '' THEN source_marc = existing_marc; target_marc = incoming_marc; replace_rule = dyn_profile.preserve_rule; ELSE source_marc = incoming_marc; target_marc = existing_marc; replace_rule = dyn_profile.replace_rule; END IF; RETURN vandelay.merge_record_xml( target_marc, source_marc, dyn_profile.add_rule, replace_rule, dyn_profile.strip_rule ); END;]]> '' THEN -- Vandelay.pm sets the value to 'usrname' when needed. SELECT id INTO new_editor FROM actor.usr WHERE usrname = editor_string; IF new_editor IS NULL THEN SELECT usr INTO new_editor FROM actor.card WHERE barcode = editor_string; END IF; IF new_editor IS NOT NULL THEN new_edit_date := NOW(); ELSE -- No valid editor, use current values new_editor = eg_marc_row.editor; new_edit_date = eg_marc_row.edit_date; END IF; ELSE new_editor = eg_marc_row.editor; new_edit_date = eg_marc_row.edit_date; END IF; dyn_profile := vandelay.compile_profile( v_marc ); IF merge_profile_id IS NOT NULL THEN SELECT * INTO merge_profile FROM vandelay.merge_profile WHERE id = merge_profile_id; IF FOUND THEN dyn_profile.add_rule := BTRIM( dyn_profile.add_rule || ',' || COALESCE(merge_profile.add_spec,''), ','); dyn_profile.strip_rule := BTRIM( dyn_profile.strip_rule || ',' || COALESCE(merge_profile.strip_spec,''), ','); dyn_profile.replace_rule := BTRIM( dyn_profile.replace_rule || ',' || COALESCE(merge_profile.replace_spec,''), ','); dyn_profile.preserve_rule := BTRIM( dyn_profile.preserve_rule || ',' || COALESCE(merge_profile.preserve_spec,''), ','); END IF; END IF; IF dyn_profile.replace_rule <> '' AND dyn_profile.preserve_rule <> '' THEN -- RAISE NOTICE 'both replace [%] and preserve [%] specified', dyn_profile.replace_rule, dyn_profile.preserve_rule; RETURN FALSE; END IF; IF dyn_profile.replace_rule = '' AND dyn_profile.preserve_rule = '' AND dyn_profile.add_rule = '' AND dyn_profile.strip_rule = '' THEN --Since we have nothing to do, just return a NOOP "we did it" RETURN TRUE; ELSIF dyn_profile.replace_rule <> '' THEN source_marc = v_marc; target_marc = eg_marc; replace_rule = dyn_profile.replace_rule; ELSE source_marc = eg_marc; target_marc = v_marc; replace_rule = dyn_profile.preserve_rule; END IF; UPDATE authority.record_entry SET marc = vandelay.merge_record_xml( target_marc, source_marc, dyn_profile.add_rule, replace_rule, dyn_profile.strip_rule ), editor = new_editor, edit_date = new_edit_date WHERE id = eg_id; IF NOT FOUND THEN -- Import/merge failed. Nothing left to do. RETURN FALSE; END IF; -- Authority record successfully merged / imported. -- Update the vandelay record to show the successful import. UPDATE vandelay.queued_authority_record SET imported_as = eg_id, import_time = NOW() WHERE id = import_id; RETURN TRUE; END;]]> '' THEN SELECT usr INTO editor_id FROM actor.card WHERE barcode = editor_string; IF editor_id IS NULL THEN SELECT id INTO editor_id FROM actor.usr WHERE usrname = editor_string; END IF; IF editor_id IS NOT NULL THEN --only update the edit date if we have a valid editor update_fields := ARRAY_APPEND( update_fields, 'editor = ' || editor_id || ', edit_date = NOW()'); END IF; END IF; END IF; IF ARRAY_LENGTH(update_fields, 1) > 0 THEN update_query := 'UPDATE biblio.record_entry SET ' || ARRAY_TO_STRING(update_fields, ',') || ' WHERE id = ' || eg_id || ';'; EXECUTE update_query; END IF; RETURN TRUE; END;]]> 'UTF-8'); use MARC::Charset; MARC::Charset->assume_unicode(1); my $target_xml = shift; my $source_xml = shift; my $field_spec = shift; my $target_r = MARC::Record->new_from_xml($target_xml); my $source_r = MARC::Record->new_from_xml($source_xml); return $target_xml unless $target_r && $source_r; # Extract the field_spec components into MARC tags, subfields, # and regex matches. Copied wholesale from vandelay.strip_field() my @field_list = split(',', $field_spec); my %fields; for my $f (@field_list) { $f =~ s/^\s*//; $f =~ s/\s*$//; if ($f =~ /^(.{3})(\w*)(?:\[([^]]*)\])?$/) { my $field = $1; $field =~ s/\s+//; my $sf = $2; $sf =~ s/\s+//; my $match = $3; $match =~ s/^\s*//; $match =~ s/\s*$//; $fields{$field} = { sf => [ split('', $sf) ] }; if ($match) { my ($msf,$mre) = split('~', $match); if (length($msf) > 0 and length($mre) > 0) { $msf =~ s/^\s*//; $msf =~ s/\s*$//; $mre =~ s/^\s*//; $mre =~ s/\s*$//; $fields{$field}{match} = { sf => $msf, re => qr/$mre/ }; } } } } # Returns a flat list of subfield (code, value, code, value, ...) # suitable for adding to a MARC::Field. sub generate_replacement_subfields { my ($source_field, $target_field, @controlled_subfields) = @_; # Performing a wholesale field replacment. # Use the entire source field as-is. return map {$_->[0], $_->[1]} $source_field->subfields unless @controlled_subfields; my @new_subfields; # Iterate over all target field subfields: # 1. Keep uncontrolled subfields as is. # 2. Replace values for controlled subfields when a # replacement value exists on the source record. # 3. Delete values for controlled subfields when no # replacement value exists on the source record. for my $target_sf ($target_field->subfields) { my $subfield = $target_sf->[0]; my $target_val = $target_sf->[1]; if (grep {$_ eq $subfield} @controlled_subfields) { if (my $source_val = $source_field->subfield($subfield)) { # We have a replacement value push(@new_subfields, $subfield, $source_val); } else { # no replacement value for controlled subfield, drop it. } } else { # Field is not controlled. Copy it over as-is. push(@new_subfields, $subfield, $target_val); } } # Iterate over all subfields in the source field and back-fill # any values that exist only in the source field. Insert these # subfields in the same relative position they exist in the # source field. my @seen_subfields; for my $source_sf ($source_field->subfields) { my $subfield = $source_sf->[0]; my $source_val = $source_sf->[1]; push(@seen_subfields, $subfield); # target field already contains this subfield, # so it would have been addressed above. next if $target_field->subfield($subfield); # Ignore uncontrolled subfields. next unless grep {$_ eq $subfield} @controlled_subfields; # Adding a new subfield. Find its relative position and add # it to the list under construction. Work backwards from # the list of already seen subfields to find the best slot. my $done = 0; for my $seen_sf (reverse(@seen_subfields)) { my $idx = @new_subfields; for my $new_sf (reverse(@new_subfields)) { $idx--; next if $idx % 2 == 1; # sf codes are in the even slots if ($new_subfields[$idx] eq $seen_sf) { splice(@new_subfields, $idx + 2, 0, $subfield, $source_val); $done = 1; last; } } last if $done; } # if no slot was found, add to the end of the list. push(@new_subfields, $subfield, $source_val) unless $done; } return @new_subfields; } # MARC tag loop for my $f (keys %fields) { my $tag_idx = -1; for my $target_field ($target_r->field($f)) { # field spec contains a regex for this field. Confirm field on # target record matches the specified regex before replacing. if (exists($fields{$f}{match})) { next unless (grep { $_ =~ $fields{$f}{match}{re} } $target_field->subfield($fields{$f}{match}{sf})); } my @new_subfields; my @controlled_subfields = @{$fields{$f}{sf}}; # If the target record has multiple matching bib fields, # replace them from matching fields on the source record # in a predictable order to avoid replacing with them with # same source field repeatedly. my @source_fields = $source_r->field($f); my $source_field = $source_fields[++$tag_idx]; if (!$source_field && @controlled_subfields) { # When there are more target fields than source fields # and we are replacing values for subfields and not # performing wholesale field replacment, use the last # available source field as the input for all remaining # target fields. $source_field = $source_fields[$#source_fields]; } if (!$source_field) { # No source field exists. Delete all affected target # data. This is a little bit counterintuitive, but is # backwards compatible with the previous version of this # function which first deleted all affected data, then # replaced values where possible. if (@controlled_subfields) { $target_field->delete_subfield($_) for @controlled_subfields; } else { $target_r->delete_field($target_field); } next; } my @new_subfields = generate_replacement_subfields( $source_field, $target_field, @controlled_subfields); # Build the replacement field from scratch. my $replacement_field = MARC::Field->new( $target_field->tag, $target_field->indicator(1), $target_field->indicator(2), @new_subfields ); $target_field->replace_with($replacement_field); } } $target_xml = $target_r->as_xml_record; $target_xml =~ s/^<\?.+?\?>$//mo; $target_xml =~ s/\n//sgo; $target_xml =~ s/>\s+ 'UTF-8'); use MARC::Charset; use strict; MARC::Charset->assume_unicode(1); my $xml = shift; my $r = MARC::Record->new_from_xml( $xml ); return $xml unless ($r); my $field_spec = shift; my @field_list = split(',', $field_spec); my %fields; for my $f (@field_list) { $f =~ s/^\s*//; $f =~ s/\s*$//; if ($f =~ /^(.{3})(\w*)(?:\[([^]]*)\])?$/) { my $field = $1; $field =~ s/\s+//; my $sf = $2; $sf =~ s/\s+//; my $matches = $3; $matches =~ s/^\s*//; $matches =~ s/\s*$//; $fields{$field} = { sf => [ split('', $sf) ] }; if ($matches) { for my $match (split('&&', $matches)) { $match =~ s/^\s*//; $match =~ s/\s*$//; my ($msf,$mre) = split('~', $match); if (length($msf) > 0 and length($mre) > 0) { $msf =~ s/^\s*//; $msf =~ s/\s*$//; $mre =~ s/^\s*//; $mre =~ s/\s*$//; $fields{$field}{match}{$msf} = qr/$mre/; } } } } } for my $f ( keys %fields) { for my $to_field ($r->field( $f )) { if (exists($fields{$f}{match})) { my @match_list = grep { $to_field->subfield($_) =~ $fields{$f}{match}{$_} } keys %{$fields{$f}{match}}; next unless (scalar(@match_list) == scalar(keys %{$fields{$f}{match}})); } if ( @{$fields{$f}{sf}} ) { $to_field->delete_subfield(code => $fields{$f}{sf}); } else { $r->delete_field( $to_field ); } } } $xml = $r->as_xml_record; $xml =~ s/^<\?.+?\?>$//mo; $xml =~ s/\n//sgo; $xml =~ s/>\s+ '' AND dyn_profile.preserve_rule <> '' THEN -- RAISE NOTICE 'both replace [%] and preserve [%] specified', dyn_profile.replace_rule, dyn_profile.preserve_rule; RETURN FALSE; END IF; IF dyn_profile.replace_rule = '' AND dyn_profile.preserve_rule = '' AND dyn_profile.add_rule = '' AND dyn_profile.strip_rule = '' THEN --Since we have nothing to do, just return a NOOP "we did it" RETURN TRUE; ELSIF dyn_profile.replace_rule <> '' THEN source_marc = v_marc; target_marc = eg_marc; replace_rule = dyn_profile.replace_rule; ELSE source_marc = eg_marc; target_marc = v_marc; replace_rule = dyn_profile.preserve_rule; END IF; UPDATE biblio.record_entry SET marc = vandelay.merge_record_xml( target_marc, source_marc, dyn_profile.add_rule, replace_rule, dyn_profile.strip_rule ) WHERE id = eg_id; IF NOT FOUND THEN -- RAISE NOTICE 'update of biblio.record_entry failed'; RETURN FALSE; END IF; RETURN TRUE; END;]]>