This review was requested by one of the module's authors, belg4mit. A while ago, we discussed some easier ways of using DBI, and of course his EZDBI and my DBIx::Simple were mentioned. I will not discuss DBIx::Simple in this review. If anyone wants to review it, please do so.

What is EZDBI?
EZDBI (Easy DBI) is a module that provides functions for database connections, using DBI as its backend. Many people find DBI either too hard or too much work (why fetchrow_arrayref if you can have something shorter?), and several modules try to end that problem. EZDBI uses no object orientation, so anyone without too much programming experience can install and use the module immediately. I review version 0.1.

Its name
Normally, modules in CPAN have some sort of hierarchy. It isn't always consistent or well-chosen, but most modules are grouped in top-level namespaces. DBI extensions should be in the DBIx:: namespace (that's right, not even DBI::), but this one uses a top-level namespace of its own. It is hard to find when searching CPAN: when using keywords like 'Easy' and 'Simple' in a module-name search, EZDBI is not one of the results. Even when you look for modules with 'DBI' in the name, EZDBI is unclear until you pronounce it letter by letter in English (which may not be a natural thing to do for those who don't natively speak English). There is a module called EasyDB, one called DBIx::Easy and one called EZDBI. That isn't very handy.

Connecting to a database
The connecting function is simply called Connect. It's a straightforward function call that takes either a DBI DSN or named arguments.

Querying
Of course, the most important thing you will want to do with a database module is sending queries to the database and getting results. EZDBI provides a function for each of the most used SQL commands: Select, Insert, Update, Delete. If you have a normal database select like SELECT foo FROM bar, you would put the Select part outside of the quotes and have Select 'foo From bar';. I changed FROM to From to match the ucfirsted Select.

The Select function is rather intelligent. By default, it fetches everything and returns it, but it can also return an object that can be used to fetch one row at a time. Insert has a nice ??L shortcut that is turned into (?, ?, ?, ...) with as many question marks as the number of remaining arguments.

There is Sql for when the given functions cannot execute the SQL you want it to. Unfortunately, this uses DBI's do, so don't expect to be able to get information out of it (For example with mysql's SHOW TABLES command).

Documentation
Every module needs documentation. Without the documentation, I wouldn't be able to write this review, as I didn't actually test the module thoroughly. I did not have to, as the manual provided almost everything I wanted to know, and the source gave me the rest of the clues. Although the programming style itself is not the one I like, the manual is very clear and easy to read. It is written with beginning programmers in mind, so the EZ is worth its bits. I especially like the vivid examples.

However, I found something in the documentation that bothers me. EZDBI's manual states that EZDBI takes care of ? placeholders, but this module only expands its special ??L placeholder (which is in turn only for Insert). Placeholder substitution is performed by DBI's execute(), but up to three times, EZDBI takes credit for what DBI does.

Multiple databases
This is quite a hassle with EZDBI. You can have multiple databases, but you'll have to use Use, which can be compared to Perl's own select that selects a filehandle. This way, copying data from one database to another (which is not uncommon: a lot of people migrate from MySQL to Postgres, for example) has to be done using temporary variables and a lot of Use calls. I don't think this is EZ, object orientation would be so much better for this.

Disconnecting
When the Perl interpreter ends, it will destroy all variables, including the DBI object that is stored inside of EZDBI. That way, database connections are properly terminated. If the end of the interpreter never happens (i.e. when using PPerl or mod_perl), you're stuck with the database connection even after your script ends. You will have to explicitly call Disconnect. EZDBI is not object oriented, so there is no object to destroy automatically when it goes out of scope. This is potentially very dangerous.

Conclusion
I wouldn't use EZDBI myself, but not because the module is bad. It's a very good module, but I happen to like object orientation, and I prefer raw SQL to semi-abstracted SQL. Maybe I'll steal the ??L idea one day, though. If object orientation is too hard for you, or if you want to do things the easiest way, EZDBI is perfect for you. Don't forget to Disconnect explicitly when using EZDBI in mod_perl, because otherwise someone else might be able to access to your database!

This is the very first module review I've ever written. Please tell me if I did anything wrong (reply).

Summary:

HTML::FromText is a clever and handy module, but it lacks flexibility.

Author:

Gareth D. Rees.

Description:

HTML::FromText takes ascii text and marks it up into web-friendly HTML based on a few fairly well-defined conventions, including the familiar *bold* and _underline_ indicators you'll recognize from Usenet and email. It'll also escape HTML metacharacters, preserve whitespace when sensical, and even recognize and mark up tables. This is excellent news for those of us who absolutely despise writing raw HTML, but are too macho to use WYSIWYG editors.

Using HTML::FromText couldn't be simpler: there's only one function you care about, and it has a nice clean interface:

my $html_code = text2html($text, %args);
[download]

For a full description of the available options, I'll refer you to the excellent HTML::FromText documentation, but here are some examples of flags you can set (or clear) in %args:

• paras: treat text as paragraph-oriented
• blockcode: mark up indented paragraphs as code
• bullets: mark up bulleted paragraphs as an unordered list
• tables: guess/recognize tables in the text and mark them up in proper HTML

Better yet, HTML::FromText produces remarkably clean, if not exactly elegant, HTML.

What could be better? Well....

HTML::FromText isn't particularly flexible. Want to mark up _foo_ as <i>foo</i>? Too bad, you're locked into underline tags. Jealous of Perl Monks' [link] convention? Sorry, you can't easily build one on top of HTML::FromText -- it'll only do two balanced delimiters. Want to treat some indented paragraphs as code and others as quotes in the same document? No can do, it's a global option.

Since there are only a few different behaviours (mark up *text*, mark up _text_, mark up indented paragraphs, mark up lists, mark up tables), I'd have liked to see a callback-oriented interface, with the existing behaviours as defaults. That way, I could replace the underscore callback with my own (to do italicised text), rewrite the headings and titles callbacks to use somewhat less exuberant header tags, and hack together a smarter callback for indented paragraphs that tries to guess whether the text in question is code or a quote, and do the right thing.

This wouldn't be so big a deal if you could escape raw HTML, but you can't. It's either convert all HTML metacharacters to their corresponding entities, or none. This is an obnoxious omission: I like to be able to keep <s and >s in my text without having to escape them by hand, but if HTML::FromText isn't going to do it for me, I'd like to be able to italicize text, too.

And would it really be so hard to recognize a line of more than, say, ten hyphens as a <hr>? That would really come in handy.

I've spent quite a bit of text ranting about its shortcomings, but I really like HTML::FromText. It's a godsend to those of us who hate HTML, but love our text editors.

Ups:

• Does an excellent job of translating text to HTML
• Table recognition is intuitive and seamless
• Good documentation
• Clean interface

Downs:

• Doesn't support some fairly obvious markups
• Inflexible

Conclusion:

Excellent for translating simple documents to HTML. Don't use it to write your website, since it only does bare-bones markup. On second thought: do use it to write your website, since you'll end up with far less bloat.:-)

Update: Added author information. Thanks Juerd!

Acme::Don't

This module, from the warped mind of Damian Conway, provides only one export, the don't command. This command is used in exactly the same way as the do BLOCK function except that, instead of executing the block it controls, to quote the module POD, "it...well...doesn't".

The result of wrapping a code block by the don't command is a no-operation which, regardless of the contents of the block, returns undef.

Why review this module? Well, in contrast to many of the other modules which have found their way into the Acme:: namespace, I can actually see a use for this module in development. How many time have you been working on some code and wanted to comment out a section of it to test specific code components? With Acme::Don't, it is as simple as adding the surrounding don't block! The only caveat with this debugging and development approach is that code within the don't block must be syntactically valid, providing compile time-syntax checks without execution. Additionally, it should be recognised that this statement is not all encompassing with BEGIN blocks placed within a don't block still being executed - For example:

use Acme::Don't;

don't {
    BEGIN {
        print "foo";
    }
    print "bar!\n";
}
[download]

The above code still produces the output of "foo" as a result of the BEGIN block execution.

Other caveats of this interesting module are included in the module documentation and while this module resides within in the Acme:: namespace it might just be something more than a gimmick and an interesting use for Perl4 module pragma :-)

ExtUtils::ModuleMaker vs h2xs

ExtUtils::ModuleMaker is a replacement for h2xs. So what's wrong with h2xs anyway and how does ExtUtils::ModuleMaker perform any better?

h2xs -AXn Foo::Bar

My annoyances with h2xs (these are purely personal):

• by default: it produces code that isn't backwards compatible [see note] (our instead of use vars, use warnings, and use 5.00?)
• you have extra work if you have more than one module in the distribution
• you have lots of editing to do before you get started, (unless your name is A. U. Thor)
• module code and tests are all dumped into the main directory

On reflection, these seem quite petty -- but I am very lazy.

perl -MExtUtils::ModuleMaker -e "Quick_Module ('Foo::Bar')"

This is more to type, and produces similar results to h2xs. However there are the following improvements:

• module files are neatly stored in a "lib" folder
• test file is created in "t" subfolder
• LICENSE file is included - defaults to perl license (GPL & Artistic)
• lib/Foo/Bar.pm is backwards compatible with perl 5.005
• useful pod sample for documenting subroutines

Advanced use of ExtUtils::ModuleMaker

The QuickModule() function still leaves A.U. Thor as the author of your work and other defaults and leaves you with only one module in your distribution. Use Generate_Module_Files() for a more complete solution...

Generate_Module_Files()

• Specify author details, (fills in the pod, Makefile.PL, etc)
• Specify version number to start on
• Specify the license that your module is released under (over 20 licenses included - or use custom)
• Create module and test files for additional modules

Here is my code using ExtUtils::ModuleMaker that allows me to be extra lazy:

#!/usr/bin/perl5.6.1 -w
use strict;
use Getopt::Long;
use ExtUtils::ModuleMaker;

my %author = 
(
  NAME => 'Simon Flack',
  EMAIL => 'simonflk@example.com',
  CPANID => 'SIMONFLK',
  WEBSITE => 'http://www.simonflack.com',
);

# Set some defaults
my $license = 'perl';
my $version = '0.1';
my $module_name = '';
my $extra_modules = '';
my @extra_modules = ();

GetOptions
(
  'name=s' => \$module_name, 
  'version:f' => \$version, 
  'license:s' => \$license, 
  'extra:s'=> \$extra_modules
);

Usage() unless $module_name;

######################################################################
+#########
# Now make the module
######################################################################
+#########

push @extra_modules, {NAME => $_, ABSTRACT => $_}
    for split /,/, $extra_modules;

Generate_Module_Files
(
 NAME => $module_name,
 ABSTRACT => $module_name,
 AUTHOR => \%author,
 VERSION => $version,
 LICENSE => $license,
 EXTRA_MODULES => \@extra_modules,
);


sub Usage
{
    my ($prog) = $0 =~ /\/([^\/]+)$/;
print <<HELP;
$prog - Simple Module Maker

Usage: $prog <-name ModuleName> [-version=?] [-extra=?,?] [-license=?]

Eg:    $prog -name My::Module
       $prog -name My::Module -version 0.11
                    -extra My::Utils,My::Extra -license perl

HELP
}
[download]

Now I can write: "newmodule -n Foo::Bar -v 1.0 -l gpl" and I can start coding and writing tests straight away...

Note: If you use this, don't forget to change the author info.

Problems with ExtUtils::ModuleMaker

There aren't many.

• ExtUtils::ModuleMaker won't be helpful if you are writing XS modules. You should stick to h2xs for this, probably.
• The .pm files it creates encourage inline pod for documenting subroutines. I know a lot of people do this, but I prefer putting my pod at the bottom.
• The test files are obscurely named, you'll probably want to rename them.

Reference:

See the following docs for more information about writing modules

ExtUtils::ModuleMaker
perlnewmod
perlmod
perlmodlib
Makefile.PL best practices by Matts
How to make a CPAN Module Distribution by tachyon
Simple Module Tutorial by tachyon
Make.pm A perl make. I prefer this to nmake on win32. pmake dist works. do "ppm install make"

update: h2xs compatibility
crazyinsomniac pointed out that h2xs has a backwards compatibility option "-b" I couldn't find this documented and it didn't work when I tried it (my v5.6.0 h2xs is higher up in the PATH than my 5.6.1 h2xs). It seems that is is a new option since perl5.6.1. I'll leave my original statement in here because it will still apply to some people on older perls. Thanks to crazyinsomniac for pointing out this option.

Overview

The Meat

The bugs

my $telnetObj = new Net::Telnet (Timeout => 20, Prompt => '/[^ <-]\>/'
+, Errmode => "return") ;
my $tmp = $^W ;
local($^W) = 0;  
$telnetObj->open(Host => $gw_in_addr) ; #offending code in here 
$^W = $tmp;
[download]

Introduction

You've probably used the Unix diff program, or one of its Win32 descendants, or some program that depends directly on it, such as patch, or the CVS source code maintenance system. All of these require calculating the smallest set of differences between two sequences (or equivalently, figuring out the longest subsequences that are the same). It's an intuitively simple problem, but surprisingly difficult to solve and implement correctly. That's what this module does, and it does it well.

Genealogy

The algorithm implemented in the module was originally published in a May 1977 Communications of the ACM article entitled "A Fast Algorithm for Computing Longest Common Subsequences" by J. W. Hunt and T. G. Szymanski. The Unix diff program was originally written by D. McIlroy and J. W. Hunt, who described their work in Bell Laboratories Technical Report 41 in 1976. This module was originally written by Mark-Jason Dominus, but the existing version is by Ned Konz. It's available on CPAN (alternate).

Details

The difficulty of the algorithm precludes sitting down and just "grinding it out"; when you need it, this module's a life-saver. It provides three separate ways to get at the algorithm -- in other words, three interfaces to the core functionality. The documentation mentions these in order of increasing generality, but they're also slightly different in what they do. They are:

LCS

This routine takes two array references, and returns the longest common subsequence. In other words, the returned result is an array (or a reference to one) containing the longest run of elements which are not different.

diff

The output of this routine is the smallest set of changes that are required to bring the two input arrays into agreement. It's similar to diff output. The result is a multidimensional array; each element is a so-called "hunk" -- that is, one logical group of differences. Within each hunk are one or more arrays of three elements each: a + or - sign, the index of the item to be inserted or deleted, and the data itself.

This is a lot easier to show than to describe. This example appears in the POD, although I've reformatted it very slightly. Suppose the two input arrays contain:

a b c   e h j   l m n p
  b c d e f j k l m r s t
[download]

(spaces added for clarity). Then the routine will return the following result:

 [ 
   [ [ '-', 0, 'a'  ] ],

   [ [ '+', 2, 'd'  ] ],

   [ [ '-', 4, 'h'  ] , 
     [ '+', 4, 'f'  ] ],

   [ [ '+', 6, 'k'  ] ],

   [ [ '-', 8, 'n'  ], 
     [ '-', 9, 'p'  ], 
     [ '+', 9, 'r'  ], 
     [ '+', 10, 's' ], 
     [ '+', 11, 't' ],
   ]
]
[download]

traverse_sequences

This function works in a callback style: it examines each input array an element at a time, and calls a supplied routine depending on whether the element is an element of the LCS or not. Up to five callbacks may be defined; referring to the input sequences as A and B, they are:

MATCH

Called when the element under consideration is a member of the LCS;

DISCARD_A and DISCARD_B

Called when the item in the respective array has to be discarded to bring the lists into agreement; and

A_FINISHED and B_FINISHED

This is really a special case of the above. When one array &lq;runs out&rq; of elements, this routine is called if it is available (otherwise the DISCARD callback for the other is invoked).

When would you use each one? You might consider using LCS if all you need is the longest match between the arrays. You could use diff to print diff-like output. For example, here's an extremely simple diff program (more for illustration than usefulness):

# Suppose @i1 and @i2 contain the slurped contents
# of two input files.
foreach my $hunk (Algorithm::Diff::diff(\@i1, \@i2))
{
    print "---\n";
    foreach my $element (@$hunk)
    {
        printf "line %d %s %s",
            $element->[1]+1,
            ($element->[0] eq '+'? '>' : '<'),
            $element->[2];
    }
}
[download]

All of these routines accept a "key generation function" as an optional final argument. This is needed because internally the routine uses numeric comparison (the <=> operator, in principle). But what if the values you have are not numeric? Or if you have a more complicated data structure, such as an array of hashes (such as object instances)? The key generation function should, given a reference to an object in your array, return a numeric value that can be used to meaningfully compare it to another element. That is, it should return some sort of hash or key that represents the element. If the elements are logically the same, it should return the same value (note that the ref operator would almost never be a good choice.)

Drawbacks

To me, the key generation functions have always seemed unnatural. I'm more used to being able to supply the actual comparison function, in the style of sort or grep. But that may cause a significant performance hit -- I don't know.

Another seeming inflexibility is that the input arrays have to be in memory. It would be nice to be able to process files without having to slurp them, by providing routines which returned the next element for the given array. (But my guess is that in the worst case -- having no elements in common -- that would still end up reading both files completely into memory.)

The above two are minor nit-picks; the only real problem I have with this module is that the documentation is hard to understand. The first time I downloaded it from CPAN, it took a good deal of trial-and-error to figure out what it was really doing. But once I got the hang of it, it's been extremely useful. Hopefully this node will help in that direction.

Summary

Algorithm::Diff is fast and relatively flexible. It implements a difficult algorithm in a nice package. Take the time to read and understand the documentation, and it will serve you well.

Update 2002-Aug-21

Brother tye has written an instructive node discussing the interfaces for returning data in Algorithm::Diff icult to use. There he also shows code for a more simplified interface that may be incorporated into the module in the future. If you're trying to figure out how to use the module, that code may be of great help.

Author

Version

Rating

Author

Version

Rating

Form Data

Delimiters

Sessions

$udat{user_name} = "fred";
[download]

Configuration

EmbperlObject

Summary / Odds and Ends

#!/usr/bin/perl -w
use strict;
use Spreadsheet::WriteExcel;

# Create a new workbook called simple.xls and add
# a worksheet
my $workbook  = Spreadsheet::WriteExcel->new("simple.xls");
my $worksheet = $workbook->addworksheet();

# The general syntax is write($row, $column, $token). Note that row an
+d
# column are zero indexed


# Write some text
$worksheet->write(0, 0,  "Hi Excel!");


# Write some numbers
$worksheet->write(2, 0,  3);          # Writes 3
$worksheet->write(3, 0,  3.00000);    # Writes 3
$worksheet->write(4, 0,  3.00001);    # Writes 3.00001
$worksheet->write(5, 0,  3.14159);    # TeX revision no.?


# Write some formulas
$worksheet->write(7, 0,  '=A3 + A6');
$worksheet->write(8, 0,  '=IF(A5>3,"Yes", "No")');


# Wrte a hyperlink
$worksheet->write(10, 0, 'http://www.perl.com/');
[download]

Edit Masem 2002-01-23 - Added CODE tags

Edit abaxaba 2003-12-23 - Corrected Type - thanks ff

MIME::Lite in a Nutshell

    ### Create a new multipart message:
    $msg = MIME::Lite->new( 
                 From    =>'me@myhost.com',
                 To      =>'you@yourhost.com',
                 Cc      =>'some@other.com, some@more.com',
                 Subject =>'A message with 2 parts...',
                 Type    =>'multipart/mixed'
                 );
    

    ### Add parts (each "attach" has same arguments as "new"):
    $msg->attach(Type     =>'TEXT',   
                 Data     =>"Here's the GIF file you wanted"
                 );  
    $msg->attach(Type     =>'image/gif',
                 Path     =>'aaa000123.gif',
                 Filename =>'logo.gif',
                 Disposition => 'attachment'
                 );
[download]

    ### Format as a string:
    $str = $msg->as_string;
    

    ### Print to a filehandle (say, a "sendmail" stream):
    $msg->print(\*SENDMAIL);
[download]

    ### Send in the "best" way (the default is to use "sendmail"):
    $msg->send;
[download]

Why use Proc::ProcessTable?

This module implements platform-independent methods for obtaining information on process execution on a system from the /proc file system by filling a procstat structure for the /proc/XXX/stat file relating to a process. This process execution information includes real and effective group and user IDs, parent and group process IDs, process priorities, CPU and memory utilisation and process TTYs. The supported process attributes available via this module vary from platform to platform as a result of the changes in platform procstat structs - Supported attributes for each platform are described in the README file for each platform.

The delivery of this process information by Process::ProcessTable allows you to do away with the ugly external shell calls to utilities such as ps.

How to use Proc::ProcessTable?

The documentation for the Proc::ProcessTable module is excellent and usage of this module is very simple with only three methods exported by default - new (create new ProcessTable object), fields (returns a list of the field names/attributes supported by the module on the current architecture) and table (reads the process table and returns an array of process information).

Examples of the usage of Proc::ProcessTable module submitted previous by myself on this site can be seen here and here.

The prerequisites are nothing out of the ordinary: LWP, IO::String, XML::Node, and XML::Writer, though BioPerl does provide interfaces for several programs and databases, so to work with those, you will obviously need to have them too. Bundle::BioPerl will install all of the prerequisites for you, though I installed doing the make tango and the installation was flawless; a few tests failed out of over 1000, but that wasn't a big deal.

There are several module groups:

• Bio::AlignIO::*: wrappers for several alignment programs like clustalw and pfam.

• Bio::Annotation::*: Objects for holding annotations (simple comments, links to other databases, or literature references).

• Bio::DB::*: Interfaces to several databases, including GenBank, GenPept, SwissProt and several others.

• Bio::Factory::*: This is a set of objects for instanciating Bio::SeqAnalysisParserI, which is a generic interface for sequence analsys parsers. The idea is to give a generic interface for parse so that annotation pipelines can be built, and when a new parser or program comes along, a complete rewrite is not necessary.

• Bio::Index::*: Methods for indexing several types of databases.

• Bio::LiveSeq::*: This is a very feature rich DNA sequence object. Several types of annotations can be added here. It seems that there is a fair bit of overlap between these modules and those in Bio::SeqFeature; it is not clear to me when, if ever, you would want to use one over the other. It may just be a matter of preference.

• Bio::Location::*: Contains methods for handling location coordinants on sequences. As the documentation says, this may seem easy, but it deals with fuzzy or compound (split) locations, as well as handling rules for locations such as like 'always widest range' or 'always smallest range'.

• Bio::Root::*: Several utility modules that are inherited from in other modules.

• Bio::Seq::*: Contains extensions for the main object for sequences, Bio::Seq, including LongSeq for long (genomic) sequences and RichSeq for annotated sequences. Bio::Seq is the workhorse object, which holds nucleotide or proteins sequences, as well as annotations. It provides several handy sequence manipulation methods such as revcom (reverse complement) and translate.

• Bio::SeqFeature::*: Objects containing feature annotations of sequences; allows fairly complex relationships to be expressed between related sequences, as well as detail about individual sequences, like the locations of exons and transcripts. The list of possible options is somewhat limited, so more specific features should probably be created by subclassing the generic class.

• Bio::SeqIO::*: Handles I/O streams for several sequence database types (like GenBank annotations/features, GCG and SwissProt).

• Bio::Tools::*: Several items here, including result holders and parsers for several programs. The BLAST parser is worth its weight in gold.

• Bio::Variation::*: These appear to be modules for working with SNPs and other mutations.

New note 2002-05-20: I plan on bringing this up to date for BioPerl v1.0 as soon as possible.

I found HTML::Clean and began testing it.

This is a very easy way to shrink the static HTML done on a web site.

I used a small test site one of the developers had put together to test with.

I was able to achieve a 10% shrinkage of the total size of the directory. In the scheme of things this is not a big savings, however, as I begin to move on to the larger web sites we have built I believe a 10% savings will begin to show improved download times for our customers.

Thanks to some of the other PM members I have put together this small script to demonstrate the abilities of HTML::Clean. While I have tested this on my own directories you may want to ensure that you have backups of your html files prior to running this script on your directories since this will over write the files in the running directory.

#!/usr/bin/perl -w
use strict;
use HTML::Clean;
clean_file( $_ ) foreach glob "*.html";

sub clean_file {
    my ($filename) = shift;
    print "$filename is being cleaned!\n";
    my $h = new HTML::Clean($filename,9) or die "Couldn't load $filena
+me: $!\n";
    $h->compat();
    $h->strip();
    my $myref = $h->data();
    open(OUTPUT,">$filename") or die "Can't open $filename: $!";
    print OUTPUT $$myref;
    close(OUTPUT);
}
[download]

Edit kudra, 2002-02-26 Added paragraph breaks; added 'review' to title per ntc req

Review: CDB_File

General Summary: Good, but limited applications

The CDB_File module allows you to gain access to databases that are stored in the CDB format (by Dan Bernstein).

CDB_Files are very efficient when it comes to lookup speed. They are especially usefull when you have a large data set. The tradeoff is that CDB_Files are read-only.

If you want to update a CDB_File, you must pass a new hash of data to the CDB_File::create class method and then re-tie your old tied hash to gain access to the new data. This means if you are in a situation where you constantly need to be both acessing and updating your data file, the CDB_File format is probably not your best choice.

In benchmarking of CDB_Files vs DB_Files, I found that there is a considerable ammount of overhead in the process of tying a CDB_File vs. tying a regular DB_File, so if you are forced into a situation where you are tying a data file, accessing a single value, then un-tying, you may be better off with a DB_File (especially if you have a small data set)

If however, you have a situation where you are tying to a data file once, and doing multiple lookups with very little updates, you might want to consider CDB_Files as a very useful alternative to DB_Files.