1MARC::Doc::Tutorial(3)User Contributed Perl DocumentationMARC::Doc::Tutorial(3)
2
6 MARC::Doc::Tutorial - A documentation-only module for new users of
7 MARC::Record
8
10 perldoc MARC::Doc::Tutorial
11
13 What is MARC?
14 The MAchine Readable Cataloging format was designed by the Library of
15 Congress in the late 1960s in order to allow libraries to convert their
16 card catalogs into a digital format. The advantages of having
17 computerized card catalogs were soon realized, and now MARC is being
18 used by all sorts of libraries around the world to provide computerized
19 access to their collections. MARC data in transmission format is
20 optimized for processing by computers, so it's not very readable for
21 the normal human. For more about the MARC format, visit the Library of
22 Congress at http://www.loc.gov/marc/
23 What is this Tutorial?
25 The document you are reading is a beginners guide to using Perl to
26 processing MARC data, written in the 'cookbook' style. Inside, you will
27 find recipes on how to read, write, update and convert MARC data using
28 the MARC::Record CPAN package. As with any cookbook, you should feel
29 free to dip in at any section and use the recipe you find interesting.
30 If you are new to Perl, you may want to read from the beginning.
31 The document you are reading is distributed with the MARC::Record
33 package, however in case you are reading it somewhere else, you can
34 find the latest version at CPAN:
35 http://www.cpan.org/modules/by-module/MARC/. You'll notice that some
36 sections aren't filled in yet, which is a result of this document being
37 a work in progress. If you have ideas for new sections please make a
38 suggestion to perl4lib: https://perl4lib.perl.org/.
39 History of MARC on CPAN
41 In 1999, a group of developers began working on MARC.pm to provide a
42 Perl module for working with MARC data. MARC.pm was quite successful
43 since it grew to include many new options that were requested by the
44 Perl/library community. However, in adding these features the module
45 swiftly outgrew its own clothes, and maintenance and addition of new
46 features became extremely difficult. In addition, as libraries began
47 using MARC.pm to process large MARC data files (>1000 records) they
48 noticed that memory consumption would skyrocket. Memory consumption
49 became an issue for large batches of records because MARC.pm's object
50 model was based on the 'batch' rather than the record... so each record
51 in the file would often be read into memory. There were ways of getting
52 around this, but they were not obvious. Some effort was made to
53 reconcile the two approaches (batch and record), but with limited
54 success.
55 In mid 2001, Andy Lester released MARC::Record and MARC::Field which
57 provided a much simpler and maintainable package for processing MARC
58 data with Perl. As its name suggests, MARC::Record treats an
59 individual MARC record as the primary Perl object, rather than having
60 the object represent a given set of records. Instead of forking the two
61 projects, the developers agreed to encourage use of the MARC::Record
62 framework, and to work on enhancing MARC::Record rather than extending
63 MARC.pm further. Soon afterwards, MARC::Batch was added, which allows
64 you to read in a large data file without having to worry about memory
65 consumption.
66 In Dec., 2004, the MARC::Lint module, an extension to check the
68 validity of MARC records, was removed from the MARC::Record
69 distribution, to become a separately distributed package. This tutorial
70 contains examples for using MARC::Lint.
71 Brief Overview of MARC Classes
73 The MARC::Record package is made up of several separate packages. This
74 can be somewhat confusing to people new to Perl, or Object Oriented
75 Programming. However this framework allows easy extension, and is built
76 to support new input/output formats as their need arises. For a good
77 introduction to using the object oriented features of Perl, see the
78 perlboot documentation that came with your version of Perl.
79 Here are the packages that get installed with MARC::Record:
81 MARC::Batch
83 A convenience class for accessing MARC data contained in an
84 external file.
85 MARC::Field
87 An object for representing the indicators and subfields of a single
88 MARC field.
89 MARC::Record
91 This primary class represents a MARC record, being a container for
92 multiple MARC::Field objects.
93 MARC::Doc::Tutorial
95 This document!
96 MARC::File
98 A superclass for representing files of MARC data.
99 MARC::File::MicroLIF
101 A subclass of MARC::File for working with data encoded in the
102 MicroLIF format.
103 MARC::File::USMARC
105 A subclass of MARC::File for working with data encoded in the
106 USMARC format.
107 Help Wanted!
109 It's already been mentioned but it's worth mentioning again:
110 MARC::Doc::Tutorial is a work in progress, and you are encouraged to
111 submit any suggestions for additional recipes via the perl4lib mailing
112 list at https://perl4lib.perl.org/. Also, patches and issue reports are
113 welcome at https://github.com/perl4lib/marc-perl.
114
116 Reading a record from a file
117 Let's say you have a USMARC record in 'file.dat' and you'd like to read
118 in the record and print out its title.
119 1 ## Example R1
121 2
122 3 ## create a MARC::Batch object.
123 4 use MARC::Batch;
124 5 my $batch = MARC::Batch->new('USMARC', 'file.dat');
125 6
126 7 ## get a MARC record from the MARC::Batch object.
127 8 ## the $record will be a MARC::Record object.
128 9 my $record = $batch->next();
129 10
130 11 ## print the title contained in the record.
131 12 print $record->title(),"\n";
132 Using the distribution's 't/camel.usmarc', your result should be:
134 ActivePerl with ASP and ADO / Tobias Martinsson.
136 Iterating through a batch file
138 Now imagine that 'file.dat' actually contains multiple records and we
139 want to print the title for each of them. Our program doesn't have to
140 change very much at all: we just need to add a loop around our call to
141 "next()".
142 1 ## Example R2
144 2
145 3 ## create a MARC::Batch object.
146 4 use MARC::Batch;
147 5 my $batch = MARC::Batch->new('USMARC','file.dat');
148 6
149 7 while (my $record = $batch->next()) {
150 8
151 9 ## print the title contained in the record.
152 10 print $record->title(),"\n";
153 11
154 12 }
155 The call to the "next()" method at line 7 returns the next record from
157 the file. "next()" returns "undef" when there are no more records left
158 in the file, which causes the "while" loop to end. This is a useful
159 idiom for reading in all the records in a file. Your results with
160 'camel.usmarc' should be:
161 ActivePerl with ASP and ADO / Tobias Martinsson.
163 Programming the Perl DBI / Alligator Descartes and Tim Bunce.
164 .
165 .
166 .
167 Cross-platform Perl / Eric F. Johnson.
168 Checking for errors
170 It is a good idea to get in the habit of checking for errors. MARC/Perl
171 has been designed to help you do this. Calls to "next()" when iterating
172 through a batch file will return "undef" when there are no more records
173 to return... AND when an error was encountered (see the next recipe to
174 subvert this). You probably want to make sure that you didn't abruptly
175 stop reading a batch file because of an error.
176 1 ## Example R3
178 2
179 3 ## create a MARC::Batch object.
180 4 use MARC::Batch;
181 5 my $batch = MARC::Batch->new('USMARC','file.dat');
182 6
183 7 ## get a marc record from the MARC::Batch object.
184 8 ## $record will be a MARC::Record object.
185 9 while ( my $record = $batch->next() ) {
186 10 print $record->title(),"\n";
187 11 }
188 12
189 13 ## make sure there weren't any problems.
190 14 if ( my @warnings = $batch->warnings() ) {
191 15 print "\nWarnings were detected!\n", @warnings;
192 16 }
193 The call to "warnings()" at line 14 will retrieve any warning messages
195 and store them in @warnings. This allows you to detect when "next()"
196 has aborted prematurely (before the end of the file has been reached).
197 When a warning is detected, an explanation is sent to "STDERR". By
198 introducing an error into 'camel.usmarc', we'll receive the following
199 output to "STDOUT":
200 Warnings were detected!
202 Invalid indicators "a0" forced to blanks in record 1 for tag 245
203 Recovering from errors
205 You may want to keep reading a batch file even after an error has been
206 encountered. If so, you will want to turn strict mode off using the
207 "strict_off()" method. You can also prevent warnings from being printed
208 to "STDERR" using the "warnings_off()" method. By default, strict is on
209 as a safety precaution to prevent you from using corrupt MARC data.
210 Once off, you can turn both strict and warnings back on again with the
211 "strict_on()" and "warnings_on()" methods.
212 1 ## Example R4
214 2
215 3 use MARC::Batch;
216 4 my $batch = MARC::Batch->new('USMARC', 'file.dat');
217 5 $batch->strict_off();
218 6
219 7 while ( my $record = $batch->next() ) {
220 8 print $record->title(),"\n";
221 9 }
222 10
223 11 ## make sure there weren't any problems.
224 12 if ( my @warnings = $batch->warnings() ) {
225 13 print "\nWarnings were detected!\n", @warnings;
226 14 }
227 Introducing a second error to the 'camel.usmarc' file gives the
229 following:
230 ActivePerl with ASP and ADO / Tobias Martinsson.
232 Programming the Perl DBI / Alligator Descartes and Tim Bunce.
233 .
234 .
235 .
236 Cross-platform Perl / Eric F. Johnson.
237 Warnings were detected!
239 Invalid indicators "a0" forced to blanks in record 1 for tag 245
240 Invalid indicators "a0" forced to blanks in record 5 for tag 245
241 Looking at a field
243 Our previous examples use MARC::Record's "title()" method to easily
244 access the 245 field, but you will probably want programs that access
245 lots of other MARC fields. MARC::Record's "field()" method gives you
246 complete access to the data found in any MARC field. The "field()"
247 method returns a MARC::Field object which can be used to access the
248 data, indicators, and even the individual subfields. Our next example
249 shows how this is done.
250 1 ## Example R5
252 2
253 3 ## open a file.
254 4 use MARC::Batch;
255 5 my $batch = MARC::Batch->new('USMARC','file.dat');
256 6
257 7 ## read a record.
258 8 my $record = $batch->next();
259 9
260 10 ## get the 100 field as a MARC::Field object.
261 11 my $field = $record->field('100');
262 12 print "The 100 field contains: ",$field->as_string(),"\n";
263 13 print "The 1st indicator is ",$field->indicator(1),"\n";
264 14 print "The 2nd indicator is ",$field->indicator(2),"\n";
265 15 print "Subfield d contains: ",$field->subfield('d'),"\n";
266 Which results in something like:
268 The 100 field contains: Martinsson, Tobias, 1976-
270 The 1st indicator is 1
271 The 2nd indicator is
272 Subfield d contains: 1976-
273 As before, use a "while" loop to iterate through all the records in a
275 batch.
276 Looking at repeatable fields
278 So how do you retrieve data from repeatable fields? The "field()"
279 method can help you with this as well. In our previous example's line
280 11, the "field()" method was used in a scalar context, since the result
281 was being assigned to the variable $field. However in a list context,
282 "field()" will return all the fields in the record of that particular
283 type. For example:
284 1 ## Example R6
286 2
287 3 use MARC::Batch;
288 4 my $batch = MARC::Batch->new('USMARC','file.dat');
289 5 my $record = $batch->next();
290 6
291 7 ## get all the 650 fields (list context).
292 8 my @fields = $record->field('650');
293 9
294 10 ## examine each 650 field and print it out.
295 11 foreach my $field (@fields) {
296 12 print $field->as_string(),"\n";
297 13 }
298 Which prints out the following for the first record of
300 't/camel.usmarc':
301 Active server pages.
303 ActiveX.
304 Looking at a set of related fields
306 "field()" also allows you to retrieve similar fields using '.' as a
307 wildcard.
308 1 ## Example R7
310 2
311 3 use MARC::Batch;
312 4 my $batch = MARC::Batch->new('USMARC','file.dat');
313 5 my $record = $batch->next();
314 6
315 7 # retrieve all title fields in one shot.
316 8 foreach my $field ($record->field('2..')) {
317 9 print $field->tag(),' contains ',$field->as_string(),"\n";
318 10 }
319 Notice the shorthand in line 8 which compacts lines 7-13 of our
321 previous example. Instead of storing the fields in an array, the
322 "field()" still returns a list in the "for" loop. Line 9 uses the
323 "tag()" method which returns the tag number for a particular MARC
324 field, which is useful when you aren't certain what tag you are
325 currently dealing with. Sample output from this recipe:
326 245 contains ActivePerl with ASP and ADO / Tobias Martinsson.
328 260 contains New York : John Wiley & Sons, 2000.
329 You can also return all tags for a specific record by using '...' in
331 "field" (though, see the next recipe).
332 Looking at all the fields in a record
334 The last example in this section illustrates how to retrieve all the
335 fields in a record using the "fields()" method. This method is similar
336 to passing '...' as a wildcard (see our previous recipe for alternative
337 access).
338 1 ## Example R8
340 2
341 3 use MARC::Batch;
342 4 my $file = MARC::Batch->new('USMARC','file.dat');
343 5 my $record = $batch->next();
344 6
345 7 ## get all of the fields using the fields() method.
346 8 my @fields = $record->fields();
347 9
348 10 ## print out the tag, the indicators and the field contents.
349 11 foreach my $field (@fields) {
350 12 print
351 13 $field->tag(), " ",
352 14 defined $field->indicator(1) ? $field->indicator(1) : "",
353 15 defined $field->indicator(2) ? $field->indicator(2) : "",
354 16 " ", $field->as_string, " \n";
355 17 }
356 The above code would print the following for the first record of
358 't/camel.usmarc':
359 001 fol05731351
361 003 IMchF
362 .
363 .
364 .
365 300 xxi, 289 p. : ill. ; 23 cm. + 1 computer laser disc (4 3/4 in.)
366 500 "Wiley Computer Publishing."
367 650 0 Perl (Computer program language)
368 630 00 Active server pages.
369 630 00 ActiveX.
370
372 The examples in the Section 1 covered how to read in existing USMARC
373 data in a file. Section 2 will show you how to create a MARC record
374 from scratch. The techniques in this section would allow you to write
375 programs which create MARC records that could then be loaded into an
376 online catalog, or sent to a third party.
377 Creating a record
379 To create a new MARC record, you'll need to first create a MARC::Record
380 object, add a leader (though MARC::Record can create leaders
381 automatically if you don't specifically define one), and then create
382 and add MARC::Field objects to your MARC::Record object. For example:
383 1 ## Example C1
385 2
386 3 ## create a MARC::Record object.
387 4 use MARC::Record;
388 5 my $record = MARC::Record->new();
389 6
390 7 ## add the leader to the record. optional.
391 8 $record->leader('00903pam 2200265 a 4500');
392 9
393 10 ## create an author field.
394 11 my $author = MARC::Field->new(
395 12 '100',1,'',
396 13 a => 'Logan, Robert K.',
397 14 d => '1939-'
398 15 );
399 16 $record->append_fields($author);
400 17
401 18 ## create a title field.
402 19 my $title = MARC::Field->new(
403 20 '245','1','4',
404 21 a => 'The alphabet effect /',
405 22 c => 'Robert K. Logan.'
406 23 );
407 24 $record->append_fields($title);
408 The key to creating records from scratch is to use "append_fields()",
410 which adds a field to the end of the record. Since each field gets
411 added at the end, it's up to you to order the fields the way you want.
412 "insert_fields_before()" and "insert_fields_after()" are similar
413 methods that allow you to define where the field gets added. These
414 methods are covered in more detail below.
415
417 Sections 1 and 2 showed how to read and create USMARC data. Once you
418 know how to read and create, it becomes important to know how to write
419 the USMARC data to disk in order to save your work. In these examples,
420 we will create a new record and save it to a file called 'record.dat'.
421 Writing records to a file
423 1 ## Example W1
424 2
425 3 ## create a MARC::Record object.
426 4 use MARC::Record;
427 5 my $record = MARC::Record->new();
428 6
429 7 ## add the leader to the record. optional.
430 8 $record->leader('00903pam 2200265 a 4500');
431 9
432 10 ## create an author field.
433 11 my $author = MARC::Field->new(
434 12 '100',1,'',
435 13 a => 'Logan, Robert K.',
436 14 d => '1939-'
437 15 );
438 16
439 17 ## create a title field.
440 18 my $title = MARC::Field->new(
441 19 '245','1','4',
442 20 a => 'The alphabet effect /',
443 21 c => 'Robert K. Logan.'
444 22 );
445 23
446 24 $record->append_fields($author, $title);
447 25
448 26 ## open a filehandle to write to 'record.dat'.
449 27 open(OUTPUT, '> record.dat') or die $!;
450 28 print OUTPUT $record->as_usmarc();
451 29 close(OUTPUT);
452 The "as_usmarc()" method call at line 28 returns a scalar value which
454 is the raw USMARC data for $record. The raw data is then promptly
455 printed to the "OUTPUT" file handle. If you want to output multiple
456 records to a file, simply repeat the process at line 28 for the
457 additional records. Also of note is the "append_fields" method: unlike
458 recipe C1 which called the method once for each field added, this
459 recipe demonstrates that "append_fields" can accept multiple arguments.
460 Note to the curious: the "as_usmarc()" method is actually an alias to
462 the MARC::File::USMARC "encode()" method. Having separate "encode()"
463 methods is a design feature of the MARC class hierarchy, since it
464 allows extensions to be built that translate MARC::Record objects into
465 different data formats.
466 Debugging with "as_formatted()"
468 Since raw USMARC data isn't very easy for humans to read, it is often
469 useful to be able to see the contents of your MARC::Record object
470 represented in a 'pretty' way for debugging purposes. If you have a
471 MARC::Record object you'd like to pretty-print, use the
472 "as_formatted()" method.
473 1 ## Example W2
475 2
476 3 ## create a MARC::Record object.
477 4 use MARC::Record;
478 5 my $record = MARC::Record->new();
479 6
480 7 $record->leader('00903pam 2200265 a 4500');
481 8
482 9 $record->append_fields(
483 10 MARC::Field->new('100','1','', a=>'Logan, Robert K.', d=>'1939-'),
484 11 MARC::Field->new('245','1','4', a=>'The alphabet effect /', c=>'Robert K. Logan.')
485 12 );
486 13
487 14 ## pretty print the record.
488 15 print $record->as_formatted(), "\n";
489 This code will pretty print the contents of the newly created record:
491 LDR 00903pam 2200265 a 4500
493 100 1 _aLogan, Robert K.
494 _d1939-
495 245 14 _aThe alphabet effect /
496 _cRobert K. Logan.
497 Notice on lines 9-12 how you can add a list of new fields by creating
499 MARC::Field objects within a call to "append_fields()". This is yet
500 another shorthand method to those shown in recipes C1 and W1. For more
501 pretty-printing capabilities, try "marcdump()" in our next recipe.
502 Debugging with marcdump()
504 If you have written USMARC data to a file (as in recipe W2) and you
505 would like to verify that the data is stored correctly you can use the
506 "marcdump" command line utility that was installed with the
507 MARC::Record package:
508 % marcdump record.dat
510 record.dat
511 LDR 00122pam 2200049 a 4500
512 100 1 _aLogan, Robert K.
513 _d1939-
514 245 14 _aThe alphabet effect /
515 _cRobert K. Logan.
516 Recs Errs Filename
518 ----- ----- --------
519 1 0 record.dat
520 As you can see, this command results in the record being pretty printed
522 to your screen ("STDOUT") similarly to the "as_formatted" method from
523 recipe W2. It is useful for verifying your USMARC data after it has
524 been stored on disk. More details about debugging are found later in
525 VALIDATING.
526
528 Now that you know how to read, write and create MARC data, you have the
529 tools you need to update or edit exiting MARC data. Updating MARC data
530 is a common task for library catalogers. Sometimes there are huge
531 amounts of records that need to be touched up... and while the touch
532 ups are very detail oriented, they are also highly repetitive. Luckily,
533 computers are tireless, and not very prone to error (assuming the
534 programmer isn't).
535 When libraries receive large batches of MARC records for electronic
537 text collections such as NetLibrary, Making of America, or microfiche
538 sets like Early American Imprints, the records are often loaded into an
539 online system and then the system is used to update the records.
540 Unfortunately, not all these systems are created equal, and catalogers
541 have to spend a great deal of time touching up each individual record.
542 An alternative would be to process the records prior to import and
543 then, once in the system, the records would not need editing. This
544 scenario would save a great deal of time for the cataloger who would be
545 liberated to spend their time doing original cataloging... which
546 computers are notably bad at!
547 Adding a field
549 Imagine a batch of records in 'file.dat' that you'd like to add local
550 notes (590) to, then saving your changes:
551 1 ## Example U1
553 2
554 3 ## create our MARC::Batch object.
555 4 use MARC::Batch;
556 5 my $batch = MARC::Batch->new('USMARC','file.dat');
557 6
558 7 ## open a file handle to write to.
559 8 open(OUT,'>new.dat') or die $!;
560 9
561 10 ## read each record, modify, then print.
562 11 while ( my $record = $batch->next() ) {
563 12
564 13 ## add a 590 field.
565 14 $record->append_fields(
566 15 MARC::Field->new('590','','',a=>'Access provided by Enron.')
567 16 );
568 17
569 18 print OUT $record->as_usmarc();
570 19
571 20 }
572 21
573 22 close(OUT);
574 Preserving field order
576 As its name suggests, "append_fields()" will add the 590 field in
577 recipe U1 to the end of the record. If you want to preserve a
578 particular order, you can use the "insert_fields_before()" and
579 "insert_fields_after()" methods. In order to use these, you need to
580 locate the field you want to insert before or after. Here is an
581 example ("insert_fields_after()" works similarly):
582 1 ## Example U2
584 2
585 3 use MARC::Batch;
586 4 my $batch = MARC::Batch->new('USMARC','file.dat');
587 5 open(OUT,'>new.dat') or die $!;
588 6
589 7 ## read in each record.
590 8 while ( my $record = $batch->next() ) {
591 9
592 10 ## find the tag after 590.
593 11 my $before;
594 12 foreach ($record->fields()) {
595 13 $before = $_;
596 14 last if $_->tag() > 590;
597 15 }
598 16
599 17 ## create the 590 field.
600 18 my $new = MARC::Field->new('590','','',a=>'Access provided by Enron.');
601 19
602 20 ## insert our 590 field after the $before.
603 21 $record->insert_fields_before($before,$new);
604 22
605 23 ## and print out the new record.
606 24 print OUT $record->as_usmarc();
607 25
608 26 }
609 Deleting a field
611 You can also delete fields that you don't want. But you will probably
612 want to check that the field contains what you expect before deleting
613 it. Let's say Enron has gone out of business and the 590 field needs to
614 be deleted:
615 1 ## Example U3
617 2
618 3 use MARC::Batch;
619 4 my $batch = MARC::Batch->new('USMARC','new.dat');
620 5 open(OUT,'>newer.dat') or die $1;
621 6
622 7 while ( my $record = $batch->next() ) {
623 8
624 9 ## get the 590 record.
625 10 my $field = $record->field('590');
626 11
627 12 ## if there is a 590 AND it has the word "Enron"...
628 13 if ($field and $field->as_string() =~ /Enron/i) {
629 14
630 15 ## delete it!
631 16 $record->delete_field($field);
632 17
633 18 }
634 19
635 20 ## output possibly modified record.
636 21 print OUT $record->as_usmarc();
637 22
638 23 }
639 The 590 field is retrieved on line 10, but notice how we check that we
641 actually received a valid $field, and that it then contains the word
642 'Enron' before we delete it. You need to pass "delete_field()" a
643 MARC::Field object that can be retrieved with the "field()" method.
644 Changing existing fields
646 Perhaps rather than adding or deleting a field, you need to modify an
647 existing field. This is achieved in several steps: first, read in the
648 MARC record you want to update, and then the field you're interested
649 in. From there, call the field's "update" or "replace_with" methods to
650 modify its contents, and then resave the record. Below is an example of
651 updating existing 590 field's containing the word 'Enron' to indicate
652 that access is now provided through Arthur Andersen:
653 1 ## Example U4
655 2
656 3 use MARC::Batch;
657 4 my $batch = MARC::Batch->new('USMARC','new.dat');
658 5 open(OUT,'>newer.dat') or die $1;
659 6
660 7 while ( my $record = $batch->next() ) {
661 8
662 9 ## look for a 590 containing "Enron"...
663 10 my $field = $record->field('590');
664 11 if ($field and $field->as_string =~ /Enron/i) {
665 12
666 13 ## create a new 590 field.
667 14 my $new_field = MARC::Field->new(
668 15 '590','','', a => 'Access provided by Arthur Andersen.' );
669 16
670 17 ## replace existing with our new one.
671 18 $field->replace_with($new_field);
672 19
673 20 }
674 21
675 22 ## output possibly modified record.
676 23 print OUT $record->as_usmarc();
677 24
678 25 }
679 In this example, we used MARC::Field's method "replace_with()" to
681 replace an existing field in the record with a new field that we
682 created. To use "replace_with()", you need to retrieve the field you
683 want to replace from a MARC::Record object (line 10), create a new
684 field to replace the existing one with (lines 13-15), and then call the
685 existing field's "replace_with()" method passing the new field as an
686 argument (lines 18). You must pass "replace_with()" a valid MARC::Field
687 object.
688 Updating subfields and indicators
690 If you'd rather not replace an existing field with a new one, you can
691 also edit the contents of the field itself using the "update()" method.
692 Let's say you've got a batch of records and want to make sure that the
693 2nd indicator for the 245 field is properly set for titles that begin
694 with 'The' (where the indicator should be '4').
695 1 ## Example U5
697 2
698 3 use MARC::Batch;
699 4 my $batch = MARC::Batch->new('USMARC','file.dat');
700 5 open(OUT,'>new.dat') or die $!;
701 6
702 7 while (my $record = $batch->next()) {
703 8
704 9 ## retrieve the 245 record.
705 10 my $field_245 = $record->field('245');
706 11
707 12 ## if we got 245 and it starts with 'The'...
708 13 if ($field_245 and $field_245->as_string() =~ /^The /) {
709 14
710 15 ## if the 2nd indicator isn't 4, update
711 16 if ($field_245->indicator(2) != 4) {
712 17 $field_245->update( ind2 => 4 );
713 18 }
714 19
715 20 }
716 21
717 22 print OUT $record->as_usmarc();
718 23
719 24 }
720 In a similar fashion, you can update individual or multiple subfields:
722 $field_245->update( a => 'History of the World :', b => 'part 1' );
724 But beware, you can only update the first occurrence of a subfield
726 using "update()". If you need to do more finer grained updates, you are
727 advised to build a new field and replace the existing field with
728 "replace_with()".
729 Changing a record's leader
731 The above procedure works for fields, but editing the leader requires
732 that you use the "leader()" method. When called with no arguments,
733 "leader()" will return the current leader, and when you pass a scalar
734 value as an argument, the leader will be set to this value. This
735 example shows how you might want to update position 6 of a records
736 leader to reflect a computer file.
737 1 ## Example U6
739 2
740 3 use MARC::Batch;
741 4 my $batch = MARC::Batch->new('USMARC','file.dat');
742 5 open(OUT,'>new.dat') or die $!;
743 6 my $record = $batch->next();
744 7
745 8 ## get the current leader.
746 9 my $leader = $record->leader();
747 10
748 11 ## replace position 6 with 'm'
749 12 substr($leader,6,1) = 'm';
750 13
751 14 ## update the leader
752 15 $record->leader($leader);
753 16
754 17 ## save the record to a file
755 18 print OUT $record->as_usmarc();
756 Modifying fields without indicators
758 MARC::Record and MARC::Field are smart and know that you don't have
759 field indicators with tags less than 010. Here's an example of
760 updating/adding an 005 field to indicate a new transaction time. For a
761 little pizzazz, we use Perl's "localtime()" to generate the data we
762 need for this field.
763 1 ## Example U7
765 2
766 3 use MARC::Batch;
767 4 my $batch = MARC::Batch->new('USMARC','file.dat');
768 5 open(OUT,'>new.dat') or die $!;
769 6
770 7 while (my $record = $batch->next() ) {
771 8
772 9 ## see if there is a 005 field.
773 10 my $field_005 = $record->field('005');
774 11
775 12 ## delete it if we find one.
776 13 $record->delete_field($field_005) if $field_005;
777 14
778 15 ## figure out the contents of our new 005 field.
779 16 my ($sec,$min,$hour,$mday,$mon,$year) = localtime();
780 17 $year += 1900; $mon += 1; # catering to offsets.
781 18 my $datetime = sprintf("%4d%02d%02d%02d%02d%02d.0",
782 19 $year,$mon,$mday,$hour,$min,$sec);
783 20
784 21 ## create a new 005 field using our new datetime.
785 22 $record->append_fields( MARC::Field->new('005',$datetime) );
786 23
787 24 ## save record to a file.
788 25 print OUT $record->as_usmarc();
789 26
790 27 }
791 Reordering subfields
793 You may find yourself in the situation where you would like to
794 programmatically reorder, and possibly modify, subfields in a
795 particular field. For example, imagine that you have a batch of records
796 that have 856 fields which contain subfields z, u, and possibly 3... in
797 any order! Now imagine that you'd like to standardize the subfield z,
798 and reorder them so that subfield 3 precedes subfield z, which precedes
799 subfield u. This is tricky but can be done in the following manner:
800 read in a record, extract the existing 856 field, build a new 856 field
801 based on the existing one, replace the existing field with your newly
802 created version.
803 1 ## Example U8
805 2
806 3 use MARC::Batch;
807 4 my $batch = MARC::Batch->new('USMARC','856.dat');
808 5 open(OUT,'>856_new.dat') or die $!;
809 6
810 7 while (my $record = $batch->next()) {
811 8
812 9 my $existing = $record->field('856');
813 10
814 11 ## make sure 856 exists.
815 12 if ($existing) {
816 13
817 14 ## our ordered subfields.
818 15 my @subfields = ();
819 16
820 17 ## if we have a subfield 3, add it.
821 18 if (defined($existing->subfield('3'))) {
822 19 push(@subfields,'3',$existing->subfield('3'));
823 20 }
824 21
825 22 ## now add subfields z and u.
826 23 push(@subfields,'z','Access restricted',
827 24 'u',$existing->subfield('u'));
828 25
829 26 ## create a new 856.
830 27 my $new = MARC::Field->new(
831 28 856', $existing->indicator(1),
832 29 $existing->indicator(2), @subfields
833 30 );
834 31
835 32 ## replace the existing subfield.
836 33 $existing->replace_with($new);
837 34
838 35 }
839 36
840 37 ## write out the record
841 38 print OUT $record->as_usmarc();
842 39
843 40 }
844 Updating subject subfield x to subfield v
846 As a somewhat more complicated example, you may find yourself wanting
847 to update the last subfield x in a 650 field to be a subfield v
848 instead. With the MARC::Field "subfields()" and "replace_with()"
849 methods along with some fancy footwork this can be done relatively
850 easily.
851 1 ## Example U9
853 2
854 3 use MARC::Batch;
855 4
856 5 my $file = shift;
857 6
858 7 my $batch = MARC::Batch->new('USMARC', $file);
859 8 while ( my $record = $batch->next() ) {
860 9
861 10 # go through all 6XX fields in the record.
862 11 foreach my $subject ( $record->field( '6..' ) ) {
863 12
864 13 # extract subfields as an array of array refs.
865 14 my @subfields = $subject->subfields();
866 15
867 16 # setup an array to store our new field.
868 17 my @newSubfields = ();
869 18
870 19 # a flag to indicate that we found an subfield x.
871 20 my $foundX = 0;
872 21
873 22 # use pop() to read the subfields backwards.
874 23 while ( my $subfield = pop( @subfields ) ) {
875 24
876 25 # for convenience, pull out the subfield
877 26 # code and data from the array ref.
878 27 my ($code,$data) = @$subfield;
879 28
880 29 # if the subfield code is 'x' and
881 30 # we haven't already found one...
882 31 if ( $code eq 'x' and ! $foundX ) {
883 32
884 33 # change to a v.
885 34 $code = 'v';
886 35
887 36 # set flag so we know not to
888 37 # translate any more subfield x.
889 38 $foundX = 1;
890 39
891 40 }
892 41
893 42 # add our (potentially changed) subfield
894 43 # data to our new subfield data array.
895 44 unshift( @newSubfields, $code, $data );
896 45
897 46 }
898 47
899 48 # if we did find a subfield x, then create a new field using our
900 49 # new subfield data, and replace the old one with the new one.
901 50 if ( $foundX ) {
902 51 my $newSubject = MARC::Field->new(
903 52 $subject->tag(),
904 53 $subject->indicator(1),
905 54 $subject->indicator(2),
906 55 @newSubfields
907 56 );
908 57 $subject->replace_with( $newSubject );
909 58 }
910 59
911 60 }
912 61
913 62 # output the potentially changed record as MARC.
914 63 print $record->as_usmarc();
915 64
916 65 }
917
919 MARC::Lint, available on CPAN and in cvs on SourceForge, has some extra
920 goodies to allow you to validate records. MARC::Lint provides an
921 extensive battery of tests, and it also provides a framework for adding
922 more.
923 Using MARC::Lint
925 Here is an example of using MARC::Lint to generate a list of errors
926 present in a batch of records in a file named 'file.dat':
927 1 ## Example V1
929 2
930 3 use MARC::Batch;
931 4 use MARC::Lint;
932 5
933 6 my $batch = MARC::Batch->new('USMARC','file.dat');
934 7 my $linter = MARC::Lint->new();
935 8 my $counter = 0;
936 9
937 10 while (my $record = $batch->next() ) {
938 11
939 12 $counter++;
940 13
941 14 ## feed the record to our linter object.
942 15 $linter->check_record($record);
943 16
944 17 ## get the warnings...
945 18 my @warnings = $linter->warnings();
946 19
947 20 ## output any warnings.
948 21 if (@warnings) {
949 22
950 23 print "RECORD $counter\n";
951 24 print join("\n",@warnings),"\n";
952 25
953 26 }
954 27
955 28 }
956 MARC::Lint is quite thorough, and will check the following when
958 validating: presence of a 245 field, repeatability of fields and
959 subfields, valid use of subfield within particular fields, presence of
960 indicators and their values. All checks are based on MARC21
961 bibliographic format.
962 Customizing MARC::Lint
964 MARC::Lint makes no claim to check everything that might be wrong with
965 a MARC record. In practice, individual libraries may have their own
966 idea about what is valid or invalid. For example, a library may mandate
967 that all MARC records with an 856 field should have a subfield z that
968 reads "Connect to this resource".
969 MARC::Lint does provide a framework for adding rules. It can be done
971 using the object oriented programming technique of inheritance. In
972 short, you can create your own subclass of MARC::Lint, and then use it
973 to validate your records. Here's an example:
974 1 ## Example V2
976 2
977 3 ## first, create our own subclass of MARC::Lint.
978 4 ## should be saved in a file called MyLint.pm.
979 5
980 6 package MyLint;
981 7 use base qw(MARC::Lint);
982 8
983 9 ## add a method to check that the 856
984 10 ## fields contain a correct subfield z.
985 11 sub check_856 {
986 12
987 13 ## your method is passed the MARC::Lint
988 14 ## and MARC::Field objects for the record.
989 15 my ($self,$field) = @_;
990 16
991 17 if ($field->subfield('z') ne 'Connect to this resource') {
992 18
993 19 ## add a warning to our lint object.
994 20 $self->warn("856 subfield z must read 'Connect to this resource'.");
995 21
996 22 }
997 23
998 24 }
999 Then create a separate program that uses your subclass to validate your
1001 MARC records. You'll need to make sure your program is able to find
1002 your module (in this case, MyLint.pm)... this can be achieved by
1003 putting both MyLint.pm and the following program in the same directory:
1004 1 ## Example V3
1006 2
1007 3 use MARC::Batch;
1008 4 use MyLint;
1009 5
1010 6 my $linter = MyLint->new();
1011 7 my $batch = MARC::Batch->new('USMARC','file.marc');
1012 8 my $counter = 0;
1013 9
1014 10 while (my $record = $batch->next()) {
1015 11
1016 12 $counter++;
1017 13
1018 14 ## check the record
1019 15 $linter->check_record($record);
1020 16
1021 17 ## get the warnings, and print them out
1022 18 my @warnings = $linter->warnings();
1023 19 if (@warnings) {
1024 20 print "RECORD $counter\n";
1025 21 print join("\n",@warnings),"\n";
1026 22 }
1027 23
1028 24 }
1029 Notice how the call to "check_record()" at line 15 automatically calls
1031 the "check_record" in MARC::Lint. The property of inheritance is what
1032 makes this happen. $linter is an instance of the MyLint class, and
1033 MyLint inherits from the MARC::Lint class, which allows $linter to
1034 inherit all the functionality of a normal MARC::Lint object plus the
1035 new functionality found in the "check_856" method.
1036 Notice also that we don't have to call "check_856()" directly. The call
1038 to "check_record()" automatically looks for any "check_XXX" methods
1039 that it can call to verify the record. Pretty neat stuff. If you've
1040 added validation checks that you think could be of use to the general
1041 public, please share them on the perl4lib mailing list, or become a
1042 developer and add them to the source!
1043
1045 Brian Eno fans might catch this reference to his autobiography which
1046 was comprised of a years worth of diary entries plus extra topics at
1047 the end, and was entitled "A Year With Swollen Appendices". The
1048 following section is a grab bag group of appendices. Many of them are
1049 not filled in yet; this is because they are just ideas... so perhaps
1050 the appendices aren't that swollen yet. Feel free to suggest new ones,
1051 or to fill these in.
1052 Comparing Collections
1054 Authority Records
1055 URLs
1056 ISBN/ISSNs
1057 Call numbers
1058 Subject headings
1059 Suppose you have a batch of MARC records and you want to extract all
1060 the subject headings, generating a report of how many times each
1061 subject heading appeared in the batch:
1062 1 use MARC::File::USMARC;
1064 2 use constant MAX => 20;
1065 3
1066 4 my %counts;
1067 5
1068 6 my $filename = shift or die "Must specify filename\n";
1069 7 my $file = MARC::File::USMARC->in( $filename );
1070 8
1071 9 while ( my $marc = $file->next() ) {
1072 10 for my $field ( $marc->field("6..") ) {
1073 11 my $heading = $field->subfield('a');
1074 12
1075 13 # trailing whitespace / punctuation.
1076 14 $heading =~ s/[.,]?\s*$//;
1077 15
1078 16 # Now count it.
1079 17 ++$counts{$heading};
1080 18 }
1081 19 }
1082 20 $file->close();
1083 21
1084 22 # Sort the list of headings based on the count of each.
1085 23 my @headings = reverse sort { $counts{$a} <=> $counts{$b} } keys %counts;
1086 24
1087 25 # Take the top N hits...
1088 26 @headings = @headings[0..MAX-1];
1089 27
1090 28 # And print out the results.
1091 29 for my $heading ( @headings ) {
1092 30 printf( "%5d %s\n", $counts{$heading}, $heading );
1093 31 }
1094 Which will generate results like this:
1096 600 United States
1098 140 World War, 1939-1945
1099 78 Great Britain
1100 63 Afro-Americans
1101 61 Indians of North America
1102 58 American poetry
1103 55 France
1104 53 West (U.S.)
1105 53 Science fiction
1106 53 American literature
1107 50 Shakespeare, William
1108 48 Soviet Union
1109 46 Mystery and detective stories
1110 45 Presidents
1111 43 China
1112 40 Frontier and pioneer life
1113 38 English poetry
1114 37 Authors, American
1115 37 English language
1116 35 Japan
1117 HTML
1119 XML
1120 MARCMaker
1121 MARC::File::MARCMaker, available on CPAN and in cvs on SourceForge, is
1122 a subclass of MARC::File for working with MARC 21 data encoded in the
1123 format used by the Library of Congress MARCMaker and MARCBreaker
1124 programs (<http://www.loc.gov/marc/makrbrkr.html>) and MarcEdit ().
1125 An example of a brief record in this format:
1127 =LDR 00314nam 22001215a 4500
1129 =001 ctr00000123\
1130 =003 XX-XxUND
1131 =005 20000613133448.0
1132 =008 051029s2005\\\\xxua\\\\\\\\\\001\0\eng\\
1133 =040 \\$aXX-XxUND$cXX-XxUND
1134 =245 00$aSample of MARCMaker record.
1135 =260 \\$a[United States] :$b[S.n.],$c2005.
1136 =300 \\$a1 p. ;$c28 cm.
1137 The following example converts an ISO2709 format record into MARCMaker
1139 format.
1140 1 ## Example Maker1
1142 2
1143 3 use MARC::Batch;
1144 4 use MARC::File::MARCMaker;
1145 5
1146 6 #mrc indicates ISO2709 format
1147 7 my $mrc_in = 'in.mrc';
1148 8 #mrk indicates MARCMaker format
1149 9 my $mrk_out = 'out.mrk';
1150 10
1151 11 #initialize $batch_mrc as new MARC::Batch object
1152 12 my $batch_mrc = MARC::Batch->new('USMARC', $mrc_in);
1153 13
1154 14 #open mrk (MARCMaker) format output file
1155 15 open (OUTMRK, ">$mrk_out") || die "Cannot open $mrk_out, $!";
1156 16
1157 17 my $rec_count = 0;
1158 18 while (my $record = $batch_mrc->next()) {
1159 19 $rec_count++;
1160 20
1161 21 print OUTMRK MARC::File::MARCMaker->encode($record);
1162 22
1163 23 } # while
1164 24
1165 25 print "$rec_count records processed\n";
1166 The following example shows conversion from MARCMaker format to ISO2709
1168 format.
1169 1 ## Example Maker2
1171 2
1172 3 use MARC::Batch;
1173 4 use MARC::File::MARCMaker;
1174 5
1175 6 #mrk indicates MARCMaker format
1176 7 my $mrk_in = 'in.mrk';
1177 8 #mrc indicates ISO2709 format
1178 9 my $mrc_out = 'out.mrc';
1179 10
1180 11 #initialize $batch_mrk as new MARC::Batch object
1181 12 my $batch_mrk = MARC::Batch->new( 'MARCMaker', $mrk_in);
1182 13
1183 14 #open mrc (ISO2709) format output file
1184 15 open (OUTMRC, ">$mrc_out") || die "Cannot open $mrc_out, $!";
1185 16
1186 17 my $rec_count = 0;
1187 18 while (my $record = $batch_mrk->next()) {
1188 19 $rec_count++;
1189 20
1190 21 print OUTMRC $record->as_usmarc();
1191 22
1192 23 } # while
1193 24
1194 25 print "$rec_count records processed\n";
1195 Excel
1197 Z39.50
1198 Chris Biemesderfer was kind enough to contribute a short example of how
1199 to use MARC::Record in tandem with Net::Z3950. Net::Z3950 is a CPAN
1200 module which provides an easy to use interface to the Z39.50 protocol
1201 so that you can write programs that retrieve records from bibliographic
1202 database around the world.
1203 Chris' program is a command line utility which you run like so:
1205 ./zm.pl 0596000278
1207 where 0596000278 is an ISBN (for the 3rd edition of the Camel
1209 incidentally). The program will query the Library of Congress Z39.50
1210 server for the ISBN, and dump out the retrieved MARC record on the
1211 screen. The program is designed to lookup multiple ISBNs if you
1212 separate them with a space. This is just an example showing what is
1213 possible.
1214 1 #!/usr/bin/perl -w
1216 2
1217 3 # GET-MARC-ISBN -- Get MARC records by ISBN from a Z39.50 server
1218 4
1219 5 use strict;
1220 6 use Carp;
1221 7 use Net::Z3950;
1222 8 use MARC::Record;
1223 9
1224 10 exit if ($#ARGV < 0);
1225 11
1226 12 # We handle multiple ISBNs in the same query by assembling a
1227 13 # (potentially very large) search string with Prefix Query Notation
1228 14 # that ORs the ISBN-bearing attributes.
1229 15 #
1230 16 # For purposes of automation, we want to request batches of many MARC
1231 17 # records. I am not a Z39.50 weenie, though, and I don't know
1232 18 # offhand if there is a limit on how big a PQN query can be...
1233 19
1234 20 my $zq = "\@attr 1=7 ". pop();
1235 21 while (@ARGV) { $zq = '@or @attr 1=7 '. pop() ." $zq" }
1236 22
1237 23 ## HERE IS THE CODE FOR Z3950 REC RETRIEVAL
1238 24 # Set up connection management structures, connect
1239 25 # to the server, and submit the Z39.50 query.
1240 26
1241 27 my $mgr = Net::Z3950::Manager->new( databaseName => 'voyager' );
1242 28 $mgr->option( elementSetName => "f" );
1243 29 $mgr->option( preferredRecordSyntax => Net::Z3950::RecordSyntax::USMARC );
1244 30
1245 31 my $conn = $mgr->connect('z3950.loc.gov', '7090');
1246 32 croak "Unable to connect to server" if !defined($conn);
1247 33
1248 34 my $rs = $conn->search($zq);
1249 35
1250 36 my $numrec = $rs->size();
1251 37 print STDERR "$numrec record(s) found\n";
1252 38
1253 39 for (my $ii = 1; $ii <= $numrec; $ii++) {
1254 40
1255 41 # Extract MARC records from Z3950
1256 42 # result set, and load MARC::Record.
1257 43 my $zrec = $rs->record($ii);
1258 44 my $mrec = MARC::Record->new_from_usmarc($zrec->rawdata());
1259 45 print $mrec->as_formatted, "\n\n";
1260 46
1261 47 }
1262 Databases
1264 Here's a script that will do a Z39.50 query (using Chris Biemesderfer's
1265 zm.pl as a model), get a MARC record back, and store it as a binary
1266 blob in a MySQL table of this structure:
1267 +---------------+---------------+------+-----+---------+----------------+
1269 | Field | Type | Null | Key | Default | Extra |
1270 +---------------+---------------+------+-----+---------+----------------+
1271 | TitleID | int(7) | | PRI | NULL | auto_increment |
1272 | RecLastMod | timestamp(14) | YES | | NULL | |
1273 | ISSN | text | YES | | NULL | |
1274 | RawMARCRecord | blob | YES | | NULL | |
1275 +---------------+---------------+------+-----+---------+----------------+
1276 1 #!/usr/bin/perl -w
1278 2
1279 3 # Script that reads in a file of ISSNs, queries a Z39.50 server,
1280 4 # and stores resulting records in a database. Limitations: Only
1281 5 # stores 1 records per ISSN.
1282 6 # Last updated 2004-09-08 Mark Jordan, mjordan@sfu.ca
1283 7
1284 8 use strict;
1285 9 use Carp;
1286 10 use Net::Z3950;
1287 11 use MARC::Record;
1288 12 use DBI;
1289 13
1290 14 # DB connection settings
1291 15 my $host = "somehost";
1292 16 my $user = "someuser";
1293 17 my $password = "somepass";
1294 18 my $database = "somedb";
1295 19
1296 20 # Input file (one ISSS/line)
1297 21 my $InputFile = $ARGV[0];
1298 22
1299 23 # Prepare list of ISSNs to search
1300 24 my @ISSNs;
1301 25 open (INPUT, "< $InputFile") or die "Can't find input file\n";
1302 26 while (<INPUT>) { chomp $_; push (@ISSNs, $_); }
1303 27 close INPUT;
1304 28
1305 29
1306 30 # Set up connection management structures, connect to the server,
1307 31 # and submit the Z39.50 query.
1308 32 my $mgr = Net::Z3950::Manager->new( databaseName => 'voyager' );
1309 33 $mgr->option( elementSetName => "f" );
1310 34 $mgr->option( preferredRecordSyntax => Net::Z3950::RecordSyntax::USMARC );
1311 35 my $conn = $mgr->connect('z3950.loc.gov', '7090');
1312 36 croak "Unable to connect to server" if !defined($conn);
1313 37
1314 38
1315 39 my $handle = DBI->connect("DBI:mysql:$database:$host","$user","$password")
1316 40 or die $DBI::errstr;
1317 41
1318 42 foreach my $ISSN (@ISSNs) {
1319 43 my $zq = "\@attr 1=8 ". $ISSN;
1320 44 my $rs = $conn->search($zq);
1321 45 my $numrec = $rs->size();
1322 46 if ($numrec == 0) {
1323 47 print "Record for ISSN $ISSN not found, moving to next ISSN...\n";
1324 48 next;
1325 49 } else {
1326 50 # Extract MARC record from the result set, and invoke MARC::Record
1327 51 my $zrec = $rs->record(1);
1328 52 my $mrec = MARC::Record->new_from_usmarc($zrec->rawdata());
1329 53 my $rawdata = $zrec->rawdata();
1330 54 $rawdata = $handle->quote ($rawdata);
1331 55 # Add to db
1332 56 my $SQL = "insert into Titles values (NULL,NULL,'$ISSN',$rawdata)";
1333 57 my $cursor = $handle->prepare($SQL);
1334 58 $cursor->execute;
1335 59 print "Record for ISSN $ISSN added to database...\n";
1336 60 $cursor->finish;
1337 61 }
1338 62 }
1339 63 $handle->disconnect;
1340 64
1341 65 __END__
1342 If you want to pull records out of the same database and do something
1344 with them, here's a template script:
1345 1 #!/usr/bin/perl -w
1347 2
1348 3 # Script that gets MARC records (in blobs) from a database.
1349 4 # Last updated 2004-09-08 Mark Jordan, mjordan@sfu.ca
1350 5
1351 6 use strict;
1352 7 use MARC::Record;
1353 8 use DBI;
1354 9
1355 10 # DB connection settings
1356 11 my $mysql_host = "somehost";
1357 12 my $mysql_user = "someuser";
1358 13 my $mysql_password = "somepass*";
1359 14 my $mysql_database = "somedb";
1360 15
1361 16
1362 17 my $handle = DBI->connect("DBI:mysql:$mysql_database:$mysql_host",
1363 18 "$mysql_user","$mysql_password") or die $DBI::errstr;
1364 19
1365 20 my $SQL = "select * from Titles";
1366 21 my $cursor = $handle->prepare($SQL);
1367 22 $cursor->execute;
1368 23
1369 24 while (my @Records = $cursor->fetchrow_array) {
1370 25 my $RawMARC = $Records[3];
1371 26 my $mrec = MARC::Record->new_from_usmarc($RawMARC);
1372 27 # Print out the title
1373 28 print $mrec->title , "\n";
1374 29 }
1375 30
1376 31 $cursor->finish;
1377 32 $handle->disconnect;
1378 33
1379 34 __END__
1380 Procite/Endnote
1383 Many thanks to all the contributors who have made this document
1384 possible.
1385 • Bryan Baldus <eijabb@cpan.org>
1387 • Chris Biemesderfer <chris@seagoat.com>
1389 • Morbus Iff <morbus@disobey.com>
1391 • Mark Jordan <mjordan@sfu.ca>
1393 • Andy Lester <andy@petdance.com>
1395 • Christopher Morgan <morgan@acm.org>
1397 • Shashi Pinheiro <SPinheiro@utsa.edu>
1399 • Jackie Shieh <jshieh@umich.edu>
1401 • Ed Summers <ehs@pobox.com>
1403perl v5.34.0 2021-07-22 MARC::Doc::Tutorial(3)