Diff of /Sprout/ERDB.pm

-revision 1.87, Sun Feb 18 21:28:19 2007 UTC
+revision 1.99, Fri Jul 11 01:04:08 2008 UTC
 Line 6
      use Data::Dumper;
      use XML::Simple;
      use DBQuery;
-     use DBObject;
+     use ERDBObject;
      use Stats;
      use Time::HiRes qw(gettimeofday);
      use Digest::MD5 qw(md5_base64);
-     use FIG;
      use CGI;
+     use WikiTools;
  =head1 Entity-Relationship Database Package
 Line 373
                   'medium-string' =>
                               { sqlType => 'VARCHAR(160)',       maxLen => 160,          avgLen =>  40, sort => "",
                                 indexMod =>   0, notes => "character string, 0 to 160 characters"},
+                  'long-string' =>
+                              { sqlType => 'VARCHAR(500)',       maxLen => 500,          avglen => 255, sort => "",
+                                indexMod =>   0, notes => "character string, 0 to 500 characters"},
                  );
  # Table translating arities into natural language.
-Line 387
+Line 390
                                    Entities => 'Entity',
                                    Fields => 'Field',
                                    Indexes => 'Index',
-                                   IndexFields => 'IndexField'
+                                   IndexFields => 'IndexField',
+                                   Issues => 'Issue',
+                                   Shapes => 'Shape'
                                  },
                    KeyAttr =>    { Relationship => 'name',
                                    Entity => 'name',
-                                   Field => 'name'
+                                   Field => 'name',
+                                   Shape => 'name'
                                  },
                    SuppressEmpty => 1,
                   );
  my %XmlInOpts  = (
-                   ForceArray => ['Field', 'Index', 'IndexField', 'Relationship', 'Entity'],
+                   ForceArray => [qw(Field Index IndexField Relationship Entity Shape)],
                    ForceContent => 1,
                    NormalizeSpace => 2,
                   );
-Line 406
+Line 412
                    XMLDecl => 1,
                   );
  =head2 Public Methods
  =head3 new
- C<< my $database = ERDB->new($dbh, $metaFileName); >>
+     my $database = ERDB->new($dbh, $metaFileName);
  Create a new ERDB object.
-Line 431
+Line 436
  sub new {
      # Get the parameters.
-     my ($class, $dbh, $metaFileName, $options) = @_;
+     my ($class, $dbh, $metaFileName, %options) = @_;
      # Load the meta-data.
      my $metaData = _LoadMetaData($metaFileName);
      # Create the object.
-Line 445
+Line 450
  =head3 ShowMetaData
- C<< $erdb->ShowMetaData($fileName); >>
+     $erdb->ShowMetaData($fileName);
  This method outputs a description of the database. This description can be used to help users create
  the data to be loaded into the relations.
-Line 486
+Line 491
  =head3 DisplayMetaData
- C<< my $html = $erdb->DisplayMetaData(); >>
+     my $html = $erdb->DisplayMetaData();
  Return an HTML description of the database. This description can be used to help users create
  the data to be loaded into the relations and form queries. The output is raw includable HTML
-Line 642
+Line 647
  =head3 DumpMetaData
- C<< $erdb->DumpMetaData(); >>
+     $erdb->DumpMetaData();
  Return a dump of the metadata structure.
-Line 655
+Line 660
      return Data::Dumper::Dumper($self->{_metaData});
  }
+ =head3 GenerateWikiData
+     my @wikiLines = $erdb->GenerateWikiData();
+ Build a description of the database for the wiki. The database will be
+ organized into a single page, with sections for each entity and relationship.
+ The return value is a list of text lines.
+ =cut
+ sub GenerateWikiData {
+     # Get the parameters.
+     my ($self) = @_;
+     # We'll build the wiki text in here.
+     my @retVal = ();
+     # Get the metadata object.
+     my $metadata = $self->{_metaData};
+     # Get the title string. This will become the page name.
+     my $title = $metadata->{Title}->{content};
+     # Get the entity and relationship lists.
+     my $entityList = $metadata->{Entities};
+     my $relationshipList = $metadata->{Relationships};
+     my $shapeList = $metadata->{Shapes};
+     # Start with the introductory text.
+     push @retVal, WikiTools::Heading(2, "Introduction");
+     if (my $notes = $metadata->{Notes}) {
+         push @retVal, WikiNote($notes->{content});
+     }
+     # Generate issue list.
+     if (my $issues = $metadata->{Issues}) {
+         push @retVal, WikiTools::Heading(3, 'Issues');
+         push @retVal, WikiTools::List(map { $_->{content} } @{$issues});
+     }
+     # Start the entity section.
+     push @retVal, WikiTools::Heading(2, "Entities");
+     # Loop through the entities. Note that unlike the situation with HTML, we
+     # don't need to generate the table of contents manually, just the data
+     # itself.
+     for my $key (sort keys %$entityList) {
+         # Create a header for this entity.
+         push @retVal, "", WikiTools::Heading(3, $key);
+         # Get the entity data.
+         my $entityData = $entityList->{$key};
+         # Plant the notes here, if there are any.
+         push @retVal, _ObjectNotes($entityData);
+         # Now we list the entity's relationships (if any). First, we build a list
+         # of the relationships relevant to this entity.
+         my @rels = ();
+         for my $rel (sort keys %$relationshipList) {
+             my $relStructure = $relationshipList->{$rel};
+             if ($relStructure->{from} eq $key || $relStructure->{to} eq $key) {
+                 # Get the relationship sentence.
+                 my $relSentence = _ComputeRelationshipSentence($rel, $relStructure);
+                 # Linkify it.
+                 my $linkedRel = WikiTools::LinkMarkup("#$rel", $rel);
+                 $relSentence =~ s/$rel/$linkedRel/;
+                 push @rels, $relSentence;
+             }
+         }
+         # Add the relationships as a Wiki list.
+         push @retVal, WikiTools::List(@rels);
+         # Get the entity's relations.
+         my $relationList = $entityData->{Relations};
+         # Loop through the relations, displaying them.
+         for my $relation (sort keys %{$relationList}) {
+             my $wikiString = _WikiRelationTable($relation, $relationList->{$relation});
+             push @retVal, $wikiString;
+         }
+     }
+     # Now the entities are documented. Next we do the relationships.
+     push @retVal, WikiTools::Heading(2, "Relationships");
+     for my $key (sort keys %$relationshipList) {
+         my $relationshipData = $relationshipList->{$key};
+         # Create the relationship heading.
+         push @retVal, WikiTools::Heading(3, $key);
+         # Describe the relationship arity. Note there's a bit of trickiness involving recursive
+         # many-to-many relationships. In a normal many-to-many we use two sentences to describe
+         # the arity (one for each direction). This is a bad idea for a recursive relationship,
+         # since both sentences will say the same thing.
+         my $arity = $relationshipData->{arity};
+         my $fromEntity = $relationshipData->{from};
+         my $toEntity = $relationshipData->{to};
+         my @listElements = ();
+         my $boldCode = WikiTools::BoldCode();
+         if ($arity eq "11") {
+             push @listElements, "Each $boldCode$fromEntity$boldCode relates to at most one $boldCode$toEntity$boldCode.";
+         } else {
+             push @listElements, "Each $boldCode$fromEntity$boldCode relates to multiple $boldCode${toEntity}s$boldCode.";
+             if ($arity eq "MM" && $fromEntity ne $toEntity) {
+                 push @listElements, "Each $boldCode$toEntity$boldCode relates to multiple $boldCode${fromEntity}s$boldCode.";
+             }
+         }
+         push @retVal, WikiTools::List(@listElements);
+         # Plant the notes here, if there are any.
+         push @retVal, _ObjectNotes($relationshipData);
+         # Finally, the relationship table.
+         my $wikiString = _WikiRelationTable($key, $relationshipData->{Relations}->{$key});
+         push @retVal, $wikiString;
+     }
+     # Now loop through the miscellaneous shapes.
+     if ($shapeList) {
+         push @retVal, WikiTools::Heading(2, "Miscellaneous");
+         for my $shape (sort keys %$shapeList) {
+             push @retVal, WikiTools::Heading(3, $shape);
+             my $shapeData = $shapeList->{$shape};
+             push @retVal, _ObjectNotes($shapeData);
+         }
+     }
+     # All done. Return the lines.
+     return @retVal;
+ }
+ =head3 CreatePPO
+     ERDB::CreatePPO($erdbXMLFile, $ppoXMLFile);
+ Create a PPO XML file from an ERDB data definition XML file. At the
+ current time, the PPO XML file can be used to create a database with
+ similar functionality. Eventually, the PPO will be able to use the
+ created XML to access the live ERDB database.
+ =over 4
+ =item erdbXMLFile
+ Name of the XML data definition file for the ERDB database. This
+ file must exist.
+ =item ppoXMLFile
+ Output file for the PPO XML definition. If this file exists, it
+ will be overwritten.
+ =back
+ =cut
+ sub CreatePPO {
+     # Get the parameters.
+     my ($erdbXMLFile, $ppoXMLFile) = @_;
+     # First, we want to slurp in the ERDB XML file in its raw form.
+     my $xml = ReadMetaXML($erdbXMLFile);
+     # Create a variable to hold all of the objects in the PPO project.
+     my @objects = ();
+     # Get the relationship hash.
+     my $relationships = $xml->{Relationships};
+     # Loop through the entities.
+     my $entities = $xml->{Entities};
+     for my $entityName (keys %{$entities}) {
+         # Get the entity's data structures.
+         my $entityObject = $entities->{$entityName};
+         # We put the object's fields in here, according to their type.
+         my (@object_refs, @scalars, @indexes, @arrays);
+         # Create the ID field for the entity. We get the key type from the
+         # entity object and compute the corresponding SQL type.
+         my $type = $TypeTable{$entityObject->{keyType}}->{sqlType};
+         push @scalars, { label => 'id', type => $type };
+         # Loop through the entity fields.
+         for my $fieldName ( keys %{$entityObject->{Fields}} ) {
+             # Get the field object.
+             my $fieldObject = $entityObject->{Fields}->{$fieldName};
+             # Convert it to a scalar tag.
+             my $scalar = _CreatePPOField($fieldName, $fieldObject);
+             # If we have a relation, this field is stored in an array.
+             # otherwise, it is a scalar. The array tag has scalars
+             # stored as an XML array. In ERDB, there is only ever one,
+             # but PPO can have more.
+             my $relation = $fieldObject->{relation};
+             if ($relation) {
+                 push @arrays, { scalar => [$scalar] };
+             } else {
+                 push @scalars, $scalar;
+             }
+         }
+         # Loop through the relationships. If this entity is the to-entity
+         # on a relationship of 1M arity, then it is implemented as a PPO
+         # object reference.
+         for my $relationshipName (keys %{$relationships}) {
+             # Get the relationship data.
+             my $relationshipData = $relationships->{$relationshipName};
+             # If we have a from for this entity and an arity of 1M, we
+             # have an object reference.
+             if ($relationshipData->{to} eq $entityName &&
+                 $relationshipData->{arity} eq '1M') {
+                 # Build the object reference tag.
+                 push @object_refs, { label => $relationshipName,
+                                      type => $relationshipData->{from} };
+             }
+         }
+         # Create the indexes.
+         my $indexList = $entityObject->{Indexes};
+         push @indexes, map { _CreatePPOIndex($_) } @{$indexList};
+         # Build the object XML tree.
+         my $object = { label => $entityName,
+                        object_ref => \@object_refs,
+                        scalar => \@scalars,
+                        index => \@indexes,
+                        array => \@arrays
+                       };
+         # Push the object onto the objects list.
+         push @objects, $object;
+     }
+     # Loop through the relationships, searching for MMs. The 1Ms were
+     # already handled by the entity search above.
+     for my $relationshipName (keys %{$relationships}) {
+         # Get this relationship's object.
+         my $relationshipObject = $relationships->{$relationshipName};
+         # Only proceed if it's many-to-many.
+         if ($relationshipObject->{arity} eq 'MM') {
+             # Create the tag lists for the relationship object.
+             my (@object_refs, @scalars, @indexes);
+             # The relationship will be created as an object with object
+             # references for its links to the participating entities.
+             my %links = ( from_link => $relationshipObject->{from},
+                           to_link => $relationshipObject->{to} );
+             for my $link (keys %links) {
+                 # Create an object_ref tag for this piece of the
+                 # relationship (from or to).
+                 my $object_ref = { label => $link,
+                                    type => $links{$link} };
+                 push @object_refs, $object_ref;
+             }
+             # Loop through the intersection data fields, creating scalar tags.
+             # There are no fancy array tags in a relationship.
+             for my $fieldName (keys %{$relationshipObject->{Fields}}) {
+                 my $fieldObject = $relationshipObject->{Fields}->{$fieldName};
+                 push @scalars, _CreatePPOField($fieldName, $fieldObject);
+             }
+             # Finally, the indexes: currently we cannot support the to-index and
+             # from-index in PPO, so we just process the alternate indexes.
+             my $indexList = $relationshipObject->{Indexes};
+             push @indexes, map { _CreatePPOIndex($_) } @{$indexList};
+             # Wrap up all the stuff about this relationship.
+             my $object = { label => $relationshipName,
+                            scalar => \@scalars,
+                            object_ref => \@object_refs,
+                            index => \@indexes
+                          };
+             # Push it into the object list.
+             push @objects, $object;
+         }
+     }
+     # Compute a title.
+     my $title;
+     if ($erdbXMLFile =~ /(\/|^)([^\/]+)DBD\.xml/) {
+         # Here we have a standard file name we can use for a title.
+         $title = $2;
+     } else {
+         # Here the file name is non-standard, so we carve up the
+         # database title.
+         $title = $xml->{Title}->{content};
+         $title =~ s/\s\.,//g;
+     }
+     # Wrap up the XML as a project.
+     my $ppoXML = { project => { label => $title,
+                                 object => \@objects }};
+     # Write out the results.
+     my $ppoString = XML::Simple::XMLout($ppoXML,
+                                         AttrIndent => 1,
+                                         KeepRoot => 1);
+     Tracer::PutFile($ppoXMLFile, [ $ppoString ]);
+ }
  =head3 FindIndexForEntity
- C<< my $indexFound = ERDB::FindIndexForEntity($xml, $entityName, $attributeName); >>
+     my $indexFound = ERDB::FindIndexForEntity($xml, $entityName, $attributeName);
  This method locates the entry in an entity's index list that begins with the
  specified attribute name. If the entity has no index list, one will be
-Line 727
+Line 996
  =head3 CreateTables
- C<< $erdb->CreateTables(); >>
+     $erdb->CreateTables();
  This method creates the tables for the database from the metadata structure loaded by the
  constructor. It is expected this function will only be used on rare occasions, when the
-Line 751
+Line 1020
  =head3 CreateTable
- C<< $erdb->CreateTable($tableName, $indexFlag, $estimatedRows); >>
+     $erdb->CreateTable($tableName, $indexFlag, $estimatedRows);
  Create the table for a relation and optionally create its indexes.
-Line 807
+Line 1076
      my $estimation = undef;
      if ($estimatedRows) {
          $estimation = [$self->EstimateRowSize($relationName), $estimatedRows];
+         Trace("$estimation->[1] rows of $estimation->[0] bytes each.") if T(3);
      }
      # Create the table.
      Trace("Creating table $relationName: $fieldThing") if T(2);
-Line 821
+Line 1091
  =head3 VerifyFields
- C<< my $count = $erdb->VerifyFields($relName, \@fieldList); >>
+     my $count = $erdb->VerifyFields($relName, \@fieldList);
  Run through the list of proposed field values, insuring that all the character fields are
  below the maximum length. If any fields are too long, they will be truncated in place.
-Line 864
+Line 1134
              my $oldString = $fieldList->[$i];
              if (length($oldString) > $maxLen) {
                  # Here it's too big, so we truncate it.
-                 Trace("Truncating field $i in relation $relName to $maxLen characters from \"$oldString\".") if T(1);
+                 Trace("Truncating field $i ($fieldTypes->[$i]->{name}) in relation $relName to $maxLen characters from \"$oldString\".") if T(1);
                  $fieldList->[$i] = substr $oldString, 0, $maxLen;
                  $retVal++;
              }
-Line 876
+Line 1146
  =head3 DigestFields
- C<< $erdb->DigestFields($relName, $fieldList); >>
+     $erdb->DigestFields($relName, $fieldList);
  Digest the strings in the field list that correspond to data type C<hash-string> in the
  specified relation.
-Line 916
+Line 1186
  =head3 DigestKey
- C<< my $digested = $erdb->DigestKey($keyValue); >>
+     my $digested = $erdb->DigestKey($keyValue);
  Return the digested value of a symbolic key. The digested value can then be plugged into a
  key-based search into a table with key-type hash-string.
-Line 949
+Line 1219
  =head3 CreateIndex
- C<< $erdb->CreateIndex($relationName); >>
+     $erdb->CreateIndex($relationName);
  Create the indexes for a relation. If a table is being loaded from a large source file (as
  is the case in L</LoadTable>), it is sometimes best to create the indexes after the load.
-Line 1005
+Line 1275
  =head3 GetSecondaryFields
- C<< my %fieldTuples = $erdb->GetSecondaryFields($entityName); >>
+     my %fieldTuples = $erdb->GetSecondaryFields($entityName);
  This method will return a list of the name and type of each of the secondary
  fields for a specified entity. Secondary fields are stored in two-column tables
-Line 1046
+Line 1316
  =head3 GetFieldRelationName
- C<< my $name = $erdb->GetFieldRelationName($objectName, $fieldName); >>
+     my $name = $erdb->GetFieldRelationName($objectName, $fieldName);
  Return the name of the relation containing a specified field.
-Line 1087
+Line 1357
  =head3 DeleteValue
- C<< my $numDeleted = $erdb->DeleteValue($entityName, $id, $fieldName, $fieldValue); >>
+     my $numDeleted = $erdb->DeleteValue($entityName, $id, $fieldName, $fieldValue);
  Delete secondary field values from the database. This method can be used to delete all
  values of a specified field for a particular entity instance, or only a single value.
-Line 1170
+Line 1440
  =head3 LoadTables
- C<< my $stats = $erdb->LoadTables($directoryName, $rebuild); >>
+     my $stats = $erdb->LoadTables($directoryName, $rebuild);
  This method will load the database tables from a directory. The tables must already have been created
  in the database. (This can be done by calling L</CreateTables>.) The caller passes in a directory name;
-Line 1230
+Line 1500
  =head3 GetTableNames
- C<< my @names = $erdb->GetTableNames; >>
+     my @names = $erdb->GetTableNames;
  Return a list of the relations required to implement this database.
-Line 1247
+Line 1517
  =head3 GetEntityTypes
- C<< my @names = $erdb->GetEntityTypes; >>
+     my @names = $erdb->GetEntityTypes;
  Return a list of the entity type names.
-Line 1264
+Line 1534
  =head3 GetDataTypes
- C<< my %types = ERDB::GetDataTypes(); >>
+     my %types = ERDB::GetDataTypes();
  Return a table of ERDB data types. The table returned is a hash of hashes.
  The keys of the big hash are the datatypes. Each smaller hash has several
-Line 1283
+Line 1553
  =head3 IsEntity
- C<< my $flag = $erdb->IsEntity($entityName); >>
+     my $flag = $erdb->IsEntity($entityName);
  Return TRUE if the parameter is an entity name, else FALSE.
-Line 1310
+Line 1580
  =head3 Get
- C<< my $query = $erdb->Get(\@objectNames, $filterClause, \@params); >>
+     my $query = $erdb->Get(\@objectNames, $filterClause, \@params);
  This method returns a query object for entities of a specified type using a specified filter.
  The filter is a standard WHERE/ORDER BY clause with question marks as parameter markers and each
-Line 1318
+Line 1588
  following call requests all B<Genome> objects for the genus specified in the variable
  $genus.
- C<< $query = $erdb->Get(['Genome'], "Genome(genus) = ?", [$genus]); >>
+     $query = $erdb->Get(['Genome'], "Genome(genus) = ?", [$genus]);
  The WHERE clause contains a single question mark, so there is a single additional
  parameter representing the parameter value. It would also be possible to code
- C<< $query = $erdb->Get(['Genome'], "Genome(genus) = \'$genus\'"); >>
+     $query = $erdb->Get(['Genome'], "Genome(genus) = \'$genus\'");
  however, this version of the call would generate a syntax error if there were any quote
  characters inside the variable C<$genus>.
-Line 1335
+Line 1605
  It is possible to specify multiple entity and relationship names in order to retrieve more than
  one object's data at the same time, which allows highly complex joined queries. For example,
- C<< $query = $erdb->Get(['Genome', 'ComesFrom', 'Source'], "Genome(genus) = ?", [$genus]); >>
+     $query = $erdb->Get(['Genome', 'ComesFrom', 'Source'], "Genome(genus) = ?", [$genus]);
  If multiple names are specified, then the query processor will automatically determine a
  join path between the entities and relationships. The algorithm used is very simplistic.
-Line 1371
+Line 1641
  with an ORDER BY clause. For example, the following filter string gets all genomes for a
  particular genus and sorts them by species name.
- C<< "Genome(genus) = ? ORDER BY Genome(species)" >>
+     "Genome(genus) = ? ORDER BY Genome(species)"
  Note that the case is important. Only an uppercase "ORDER BY" with a single space will
  be processed. The idea is to make it less likely to find the verb by accident.
-Line 1384
+Line 1654
  be the last thing in the filter clause, and it contains only the word "LIMIT" followed by
  a positive number. So, for example
- C<< "Genome(genus) = ? ORDER BY Genome(species) LIMIT 10" >>
+     "Genome(genus) = ? ORDER BY Genome(species) LIMIT 10"
  will only return the first ten genomes for the specified genus. The ORDER BY clause is not
  required. For example, to just get the first 10 genomes in the B<Genome> table, you could
  use
- C<< "LIMIT 10" >>
+     "LIMIT 10"
  =item params
-Line 1411
+Line 1681
      my ($suffix, $mappedNameListRef, $mappedNameHashRef) =
          $self->_SetupSQL($objectNames, $filterClause);
      # Create the query.
-     my $command = "SELECT DISTINCT " . join(".*, ", @{$mappedNameListRef}) .
+     my $command = "SELECT " . join(".*, ", @{$mappedNameListRef}) .
          ".* $suffix";
      my $sth = $self->_GetStatementHandle($command, $params);
      # Now we create the relation map, which enables DBQuery to determine the order, name
-Line 1429
+Line 1699
  =head3 Search
- C<< my $query = $erdb->Search($searchExpression, $idx, \@objectNames, $filterClause, \@params); >>
+     my $query = $erdb->Search($searchExpression, $idx, \@objectNames, $filterClause, \@params);
  Perform a full text search with filtering. The search will be against a specified object
  in the object name list. That object will get an extra field containing the search
-Line 1512
+Line 1782
              $self->_SetupSQL($objectNames, $filterClause, $matchClause);
          # Create the query. Note that the match clause is inserted at the front of
          # the select fields.
-         my $command = "SELECT DISTINCT $matchClause, " . join(".*, ", @{$mappedNameListRef}) .
+         my $command = "SELECT $matchClause, " . join(".*, ", @{$mappedNameListRef}) .
              ".* $suffix";
          my $sth = $self->_GetStatementHandle($command, \@myParams);
          # Now we create the relation map, which enables DBQuery to determine the order, name
-Line 1526
+Line 1796
  =head3 GetFlat
- C<< my @list = $erdb->GetFlat(\@objectNames, $filterClause, \@parameterList, $field); >>
+     my @list = $erdb->GetFlat(\@objectNames, $filterClause, \@parameterList, $field);
  This is a variation of L</GetAll> that asks for only a single field per record and
  returns a single flattened list.
-Line 1579
+Line 1849
  =head3 SpecialFields
- C<< my %specials = $erdb->SpecialFields($entityName); >>
+     my %specials = $erdb->SpecialFields($entityName);
  Return a hash mapping special fields in the specified entity to the value of their
  C<special> attribute. This enables the subclass to get access to the special field
-Line 1621
+Line 1891
  =head3 Delete
- C<< my $stats = $erdb->Delete($entityName, $objectID, %options); >>
+     my $stats = $erdb->Delete($entityName, $objectID, %options);
  Delete an entity instance from the database. The instance is deleted along with all entity and
  relationship instances dependent on it. The definition of I<dependence> is recursive.
-Line 1806
+Line 2076
  =head3 Disconnect
- C<< $erdb->Disconnect($relationshipName, $originEntityName, $originEntityID); >>
+     $erdb->Disconnect($relationshipName, $originEntityName, $originEntityID);
  Disconnect an entity instance from all the objects to which it is related. This
  will delete each relationship instance that connects to the specified entity.
-Line 1845
+Line 2115
          # Loop through the ends of the relationship.
          for my $dir ('from', 'to') {
              if ($structure->{$dir} eq $originEntityName) {
-                 # Delete all relationship instances on this side of the entity instance.
-                 Trace("Disconnecting in $dir direction with ID \"$originEntityID\".");
-                 $dbh->SQL("DELETE FROM $relationshipName WHERE ${dir}_link = ?", 0, $originEntityID);
                  $found = 1;
+                 # Here we want to delete all relationship instances on this side of the
+                 # entity instance.
+                 Trace("Disconnecting in $dir direction with ID \"$originEntityID\".");
+                 # We do this delete in batches to keep it from dragging down the
+                 # server.
+                 my $limitClause = ($FIG_Config::delete_limit ? "LIMIT $FIG_Config::delete_limit" : "");
+                 my $done = 0;
+                 while (! $done) {
+                     # Do the delete.
+                     my $rows = $dbh->SQL("DELETE FROM $relationshipName WHERE ${dir}_link = ? $limitClause", 0, $originEntityID);
+                     # See if we're done. We're done if no rows were found or the delete is unlimited.
+                     $done = ($rows == 0 || ! $limitClause);
+                 }
              }
          }
          # Insure we found the entity on at least one end.
-Line 1860
+Line 2140
  =head3 DeleteRow
- C<< $erdb->DeleteRow($relationshipName, $fromLink, $toLink, \%values); >>
+     $erdb->DeleteRow($relationshipName, $fromLink, $toLink, \%values);
  Delete a row from a relationship. In most cases, only the from-link and to-link are
  needed; however, for relationships with intersection data values can be specified
-Line 1913
+Line 2193
      $dbh->SQL($command, undef, @parms);
  }
+ =head3 DeleteLike
+     my $deleteCount = $erdb->DeleteLike($relName, $filter, \@parms);
+ Delete all the relationship rows that satisfy a particular filter condition. Unlike a normal
+ filter, only fields from the relationship itself can be used.
+ =over 4
+ =item relName
+ Name of the relationship whose records are to be deleted.
+ =item filter
+ A filter clause (L</Get>-style) for the delete query.
+ =item parms
+ Reference to a list of parameters for the filter clause.
+ =item RETURN
+ Returns a count of the number of rows deleted.
+ =back
+ =cut
+ sub DeleteLike {
+     # Get the parameters.
+     my ($self, $objectName, $filter, $parms) = @_;
+     # Declare the return variable.
+     my $retVal;
+     # Insure the parms argument is an array reference if the caller left it off.
+     if (! defined($parms)) {
+         $parms = [];
+     }
+     # Insure we have a relationship. The main reason for this is if we delete an entity
+     # instance we have to yank out a bunch of other stuff with it.
+     if ($self->IsEntity($objectName)) {
+         Confess("Cannot use DeleteLike on $objectName, because it is not a relationship.");
+     } else {
+         # Create the SQL command suffix to get the desierd records.
+         my ($suffix) = $self->_SetupSQL([$objectName], $filter);
+         # Convert it to a DELETE command.
+         my $command = "DELETE $suffix";
+         # Execute the command.
+         my $dbh = $self->{_dbh};
+         my $result = $dbh->SQL($command, 0, @{$parms});
+         # Check the results. Note we convert the "0D0" result to a real zero.
+         # A failure causes an abnormal termination, so the caller isn't going to
+         # worry about it.
+         if (! defined $result) {
+             Confess("Error deleting from $objectName: " . $dbh->errstr());
+         } elsif ($result == 0) {
+             $retVal = 0;
+         } else {
+             $retVal = $result;
+         }
+     }
+     # Return the result count.
+     return $retVal;
+ }
  =head3 SortNeeded
- C<< my $parms = $erdb->SortNeeded($relationName); >>
+     my $parms = $erdb->SortNeeded($relationName);
  Return the pipe command for the sort that should be applied to the specified
  relation when creating the load file.
-Line 2013
+Line 2358
  =head3 GetList
- C<< my @dbObjects = $erdb->GetList(\@objectNames, $filterClause, \@params); >>
+     my @dbObjects = $erdb->GetList(\@objectNames, $filterClause, \@params);
  Return a list of object descriptors for the specified objects as determined by the
  specified filter clause.
-Line 2041
+Line 2386
  with an ORDER BY clause. For example, the following filter string gets all genomes for a
  particular genus and sorts them by species name.
- C<< "Genome(genus) = ? ORDER BY Genome(species)" >>
+     "Genome(genus) = ? ORDER BY Genome(species)"
  The rules for field references in a sort order are the same as those for field references in the
  filter clause in general; however, odd things may happen if a sort field is from a secondary
-Line 2053
+Line 2398
  =item RETURN
- Returns a list of B<DBObject>s that satisfy the query conditions.
+ Returns a list of B<ERDBObject>s that satisfy the query conditions.
  =back
-Line 2076
+Line 2421
  =head3 GetCount
- C<< my $count = $erdb->GetCount(\@objectNames, $filter, \@params); >>
+     my $count = $erdb->GetCount(\@objectNames, $filter, \@params);
  Return the number of rows found by a specified query. This method would
  normally be used to count the records in a single table. For example, in a
-Line 2169
+Line 2514
  =head3 ComputeObjectSentence
- C<< my $sentence = $erdb->ComputeObjectSentence($objectName); >>
+     my $sentence = $erdb->ComputeObjectSentence($objectName);
  Check an object name, and if it is a relationship convert it to a relationship sentence.
-Line 2204
+Line 2549
  =head3 DumpRelations
- C<< $erdb->DumpRelations($outputDirectory); >>
+     $erdb->DumpRelations($outputDirectory);
  Write the contents of all the relations to tab-delimited files in the specified directory.
  Each file will have the same name as the relation dumped, with an extension of DTX.
-Line 2246
+Line 2591
  =head3 InsertValue
- C<< $erdb->InsertValue($entityID, $fieldName, $value); >>
+     $erdb->InsertValue($entityID, $fieldName, $value);
  This method will insert a new value into the database. The value must be one
  associated with a secondary relation, since primary values cannot be inserted:
-Line 2309
+Line 2654
  =head3 InsertObject
- C<< $erdb->InsertObject($objectType, \%fieldHash); >>
+     $erdb->InsertObject($objectType, \%fieldHash);
  Insert an object into the database. The object is defined by a type name and then a hash
  of field names to values. Field values in the primary relation are represented by scalars.
-Line 2318
+Line 2663
  example, the following line inserts an inactive PEG feature named C<fig|188.1.peg.1> with aliases
  C<ZP_00210270.1> and C<gi|46206278>.
- C<< $erdb->InsertObject('Feature', { id => 'fig|188.1.peg.1', active => 0, feature-type => 'peg', alias => ['ZP_00210270.1', 'gi|46206278']}); >>
+     $erdb->InsertObject('Feature', { id => 'fig|188.1.peg.1', active => 0, feature-type => 'peg', alias => ['ZP_00210270.1', 'gi|46206278']});
  The next statement inserts a C<HasProperty> relationship between feature C<fig|158879.1.peg.1> and
  property C<4> with an evidence URL of C<http://seedu.uchicago.edu/query.cgi?article_id=142>.
- C<< $erdb->InsertObject('HasProperty', { 'from-link' => 'fig|158879.1.peg.1', 'to-link' => 4, evidence => 'http://seedu.uchicago.edu/query.cgi?article_id=142'}); >>
+     $erdb->InsertObject('HasProperty', { 'from-link' => 'fig|158879.1.peg.1', 'to-link' => 4, evidence => 'http://seedu.uchicago.edu/query.cgi?article_id=142'});
  =over 4
-Line 2446
+Line 2791
  =head3 UpdateEntity
- C<< $erdb->UpdateEntity($entityName, $id, \%fields); >>
+     $erdb->UpdateEntity($entityName, $id, \%fields);
  Update the values of an entity. This is an unprotected update, so it should only be
  done if the database resides on a database server.
-Line 2504
+Line 2849
  =head3 LoadTable
- C<< my $results = $erdb->LoadTable($fileName, $relationName, $truncateFlag); >>
+     my $results = $erdb->LoadTable($fileName, $relationName, %options);
  Load data from a tab-delimited file into a specified table, optionally re-creating the table
  first.
-Line 2519
+Line 2864
  Name of the relation to be loaded. This is the same as the table name.
- =item truncateFlag
+ =item options
- TRUE if the table should be dropped and re-created, else FALSE
+ A hash of load options.
  =item RETURN
-Line 2529
+Line 2874
  =back
+ The permissible options are as follows.
+ =over 4
+ =item truncate
+ If TRUE, then the table will be erased before loading.
+ =item mode
+ Mode in which the load should operate, either C<low_priority> or C<concurrent>.
+ This option is only applicable to a MySQL database.
+ =item partial
+ If TRUE, then it is assumed that this is a partial load, and the table will not
+ be analyzed and compacted at the end.
+ =back
  =cut
  sub LoadTable {
      # Get the parameters.
-     my ($self, $fileName, $relationName, $truncateFlag) = @_;
+     my ($self, $fileName, $relationName, %options) = @_;
      # Create the statistical return object.
      my $retVal = _GetLoadStats();
      # Trace the fact of the load.
-Line 2544
+Line 2909
      # Get the relation data.
      my $relation = $self->_FindRelation($relationName);
      # Check the truncation flag.
-     if ($truncateFlag) {
+     if ($options{truncate}) {
          Trace("Creating table $relationName") if T(2);
          # Compute the row count estimate. We take the size of the load file,
-         # divide it by the estimated row size, and then multiply by 1.5 to
+         # divide it by the estimated row size, and then multiply by 2 to
          # leave extra room. We postulate a minimum row count of 1000 to
          # prevent problems with incoming empty load files.
          my $rowSize = $self->EstimateRowSize($relationName);
-         my $estimate = FIG::max($fileSize * 1.5 / $rowSize, 1000);
+         my $estimate = $fileSize * 8 / $rowSize;
+         if ($estimate < 1000) {
+             $estimate = 1000;
+         }
          # Re-create the table without its index.
          $self->CreateTable($relationName, 0, $estimate);
          # If this is a pre-index DBMS, create the index here.
-Line 2567
+Line 2935
      # Load the table.
      my $rv;
      eval {
-         $rv = $dbh->load_table(file => $fileName, tbl => $relationName);
+         $rv = $dbh->load_table(file => $fileName, tbl => $relationName, style => $options{mode});
      };
      if (!defined $rv) {
          $retVal->AddMessage($@) if ($@);
-Line 2578
+Line 2946
          $retVal->Add("tables");
          my $size = -s $fileName;
          Trace("$size bytes loaded into $relationName.") if T(2);
+         $retVal->Add("bytes", $size);
          # If we're rebuilding, we need to create the table indexes.
-         if ($truncateFlag) {
+         if ($options{truncate}) {
              # Indexes are created here for PostGres. For PostGres, indexes are
              # best built at the end. For MySQL, the reverse is true.
              if (! $dbh->{_preIndex}) {
-Line 2600
+Line 2969
          }
      }
      # Analyze the table to improve performance.
+     if (! $options{partial}) {
      Trace("Analyzing and compacting $relationName.") if T(3);
      $dbh->vacuum_it($relationName);
+     }
      Trace("$relationName load completed.") if T(3);
      # Return the statistics.
      return $retVal;
-Line 2609
+Line 2980
  =head3 CreateSearchIndex
- C<< $erdb->CreateSearchIndex($objectName); >>
+     $erdb->CreateSearchIndex($objectName);
  Check for a full-text search index on the specified entity or relationship object, and
  if one is required, rebuild it.
-Line 2646
+Line 3017
  =head3 DropRelation
- C<< $erdb->DropRelation($relationName); >>
+     $erdb->DropRelation($relationName);
  Physically drop a relation from the database.
-Line 2674
+Line 3045
  =head3 MatchSqlPattern
- C<< my $matched = ERDB::MatchSqlPattern($value, $pattern); >>
+     my $matched = ERDB::MatchSqlPattern($value, $pattern);
  Determine whether or not a specified value matches an SQL pattern. An SQL
  pattern has two wild card characters: C<%> that matches multiple characters,
-Line 2757
+Line 3128
  =head3 GetEntity
- C<< my $entityObject = $erdb->GetEntity($entityType, $ID); >>
+     my $entityObject = $erdb->GetEntity($entityType, $ID);
  Return an object describing the entity instance with a specified ID.
-Line 2773
+Line 3144
  =item RETURN
- Returns a B<DBObject> representing the desired entity instance, or an undefined value if no
+ Returns a B<ERDBObject> representing the desired entity instance, or an undefined value if no
  instance is found with the specified key.
  =back
-Line 2793
+Line 3164
  =head3 GetChoices
- C<< my @values = $erdb->GetChoices($entityName, $fieldName); >>
+     my @values = $erdb->GetChoices($entityName, $fieldName);
  Return a list of all the values for the specified field that are represented in the
  specified entity.
-Line 2848
+Line 3219
  =head3 GetEntityValues
- C<< my @values = $erdb->GetEntityValues($entityType, $ID, \@fields); >>
+     my @values = $erdb->GetEntityValues($entityType, $ID, \@fields);
  Return a list of values from a specified entity instance. If the entity instance
  does not exist, an empty list is returned.
-Line 2892
+Line 3263
  =head3 GetAll
- C<< my @list = $erdb->GetAll(\@objectNames, $filterClause, \@parameters, \@fields, $count); >>
+     my @list = $erdb->GetAll(\@objectNames, $filterClause, \@parameters, \@fields, $count);
  Return a list of values taken from the objects returned by a query. The first three
  parameters correspond to the parameters of the L</Get> method. The final parameter is
-Line 2906
+Line 3277
  fields specified returns multiple values, they are flattened in with the rest. For
  example, the following call will return a list of the features in a particular
  spreadsheet cell, and each feature will be represented by a list containing the
- feature ID followed by all of its aliases.
+ feature ID followed by all of its essentiality determinations.
- C<< @query = $erdb->Get(['ContainsFeature', 'Feature'], "ContainsFeature(from-link) = ?", [$ssCellID], ['Feature(id)', 'Feature(alias)']); >>
+     @query = $erdb->Get(['ContainsFeature', 'Feature'], "ContainsFeature(from-link) = ?", [$ssCellID], ['Feature(id)', 'Feature(essential)']);
  =over 4
-Line 2986
+Line 3357
  =head3 Exists
- C<< my $found = $sprout->Exists($entityName, $entityID); >>
+     my $found = $sprout->Exists($entityName, $entityID);
  Return TRUE if an entity exists, else FALSE.
-Line 3021
+Line 3392
  =head3 EstimateRowSize
- C<< my $rowSize = $erdb->EstimateRowSize($relName); >>
+     my $rowSize = $erdb->EstimateRowSize($relName);
  Estimate the row size of the specified relation. The estimated row size is computed by adding
  up the average length for each data type.
-Line 3059
+Line 3430
  =head3 GetFieldTable
- C<< my $fieldHash = $self->GetFieldTable($objectnName); >>
+     my $fieldHash = $self->GetFieldTable($objectnName);
  Get the field structure for a specified entity or relationship.
-Line 3088
+Line 3459
  =head3 SplitKeywords
- C<< my @keywords = ERDB::SplitKeywords($keywordString); >>
+     my @keywords = ERDB::SplitKeywords($keywordString);
  This method returns a list of the positive keywords in the specified
  keyword string. All of the operators will have been stripped off,
-Line 3137
+Line 3508
  =head3 ValidateFieldName
- C<< my $okFlag = ERDB::ValidateFieldName($fieldName); >>
+     my $okFlag = ERDB::ValidateFieldName($fieldName);
  Return TRUE if the specified field name is valid, else FALSE. Valid field names must
  be hyphenated words subject to certain restrictions.
-Line 3192
+Line 3563
  =head3 ReadMetaXML
- C<< my $rawMetaData = ERDB::ReadDBD($fileName); >>
+     my $rawMetaData = ERDB::ReadDBD($fileName);
  This method reads a raw database definition XML file and returns it.
  Normally, the metadata used by the ERDB system has been processed and
-Line 3225
+Line 3596
  =head3 GetEntityFieldHash
- C<< my $fieldHashRef = ERDB::GetEntityFieldHash($structure, $entityName); >>
+     my $fieldHashRef = ERDB::GetEntityFieldHash($structure, $entityName);
  Get the field hash of the named entity in the specified raw XML structure.
  The field hash may not exist, in which case we need to create it.
-Line 3267
+Line 3638
  =head3 WriteMetaXML
- C<< ERDB::WriteMetaXML($structure, $fileName); >>
+     ERDB::WriteMetaXML($structure, $fileName);
  Write the metadata XML to a file. This method is the reverse of L</ReadMetaXML>, and is
  used to update the database definition. It must be used with care, however, since it
-Line 3306
+Line 3677
  Except for C<[p]>, all the codes are closed by slash-codes. So, for
  example, C<[b]Feature[/b]> displays the string C<Feature> in boldface.
- C<< my $realHtml = ERDB::HTMLNote($dataString); >>
+     my $realHtml = ERDB::HTMLNote($dataString);
  =over 4
-Line 3336
+Line 3707
      return $retVal;
  }
+ =head3 WikiNote
+ Convert a note or comment to Wiki text by replacing some bulletin-board codes with HTML. The codes
+ supported are C<[b]> for B<bold>, C<[i]> for I<italics>, and C<[p]> for a new paragraph.
+ Except for C<[p]>, all the codes are closed by slash-codes. So, for
+ example, C<[b]Feature[/b]> displays the string C<Feature> in boldface.
+     my $wikiText = ERDB::WikiNote($dataString);
+ =over 4
+ =item dataString
+ String to convert to Wiki text.
+ =item RETURN
+ An Wiki text string derived from the input string.
+ =back
+ =cut
+ sub WikiNote {
+     # Get the parameter.
+     my ($dataString) = @_;
+     # HTML-escape the text.
+     my $retVal = CGI::escapeHTML($dataString);
+     # Substitute the bulletin board codes.
+     my $italic = WikiTools::ItalicCode();
+     $retVal =~ s/\[\/?i\]/$italic/g;
+     my $bold = WikiTools::BoldCode();
+     $retVal =~ s/\[\/?b\]/$bold/g;
+     # Paragraph breaks are the same no matter which Wiki you're using.
+     $retVal =~ s!\[p\]!\n\n!g;
+     # Now we do the links, which are complicated by the need to know two
+     # things: the target URL and the text.
+     while ($retVal =~ /\[link\s+([^\]]+)\]([^\[]+)\[\/link\]/g) {
+         # Replace the matched string with the Wiki markup for links. Note that
+         # $-[0] is the starting position of the match for the entire expression,
+         # and $+[0] is past the ending position.
+         substr $retVal, $-[0], $+[0] - $-[0], WikiTools::LinkMarkup($1, $2);
+     }
+     # Return the result.
+     return $retVal;
+ }
  =head3 BeginTran
- C<< $erdb->BeginTran(); >>
+     $erdb->BeginTran();
  Start a database transaction.
-Line 3352
+Line 3770
  =head3 CommitTran
- C<< $erdb->CommitTran(); >>
+     $erdb->CommitTran();
  Commit an active database transaction.
-Line 3365
+Line 3783
  =head3 RollbackTran
- C<< $erdb->RollbackTran(); >>
+     $erdb->RollbackTran();
  Roll back an active database transaction.
-Line 3376
+Line 3794
      $self->{_dbh}->roll_tran();
  }
+ =head3 UpdateField
+     my $count = $erdb->UpdateField($objectNames, $fieldName, $oldValue, $newValue, $filter, $parms);
+ Update all occurrences of a specific field value to a new value. The number of rows changed will be
+ returned.
+ =over 4
+ =item fieldName
+ Name of the field in standard I<objectName>C<(>I<fieldName>C<)> format.
+ =item oldValue
+ Value to be modified. All occurrences of this value in the named field will be replaced by the
+ new value.
+ =item newValue
+ New value to be substituted for the old value when it's found.
+ =item filter
+ A standard ERDB filter clause (see L</Get>). The filter will be applied before any substitutions take place.
+ =item parms
+ Reference to a list of parameter values in the filter.
+ =item RETURN
+ Returns the number of rows modified.
+ =back
+ =cut
+ sub UpdateField {
+     # Get the parameters.
+     my ($self, $fieldName, $oldValue, $newValue, $filter, $parms) = @_;
+     # Get the object and field names from the field name parameter.
+     $fieldName =~ /^([^(]+)\(([^)]+)\)/;
+     my $objectName = $1;
+     my $realFieldName = _FixName($2);
+     # Add the old value to the filter. Note we allow the possibility that no
+     # filter was specified.
+     my $realFilter = "$fieldName = ?";
+     if ($filter) {
+         $realFilter .= " AND $filter";
+     }
+     # Format the query filter.
+     my ($suffix, $mappedNameListRef, $mappedNameHashRef) =
+         $self->_SetupSQL([$objectName], $realFilter);
+     # Create the query. Since there is only one object name, the mapped-name data is not
+     # necessary. Neither is the FROM clause.
+     $suffix =~ s/^FROM.+WHERE\s+//;
+     # Create the update statement.
+     my $command = "UPDATE $objectName SET $realFieldName = ? WHERE $suffix";
+     # Get the database handle.
+     my $dbh = $self->{_dbh};
+     # Add the old and new values to the parameter list. Note we allow the possibility that
+     # there are no user-supplied parameters.
+     my @params = ($newValue, $oldValue);
+     if (defined $parms) {
+         push @params, @{$parms};
+     }
+     # Execute the update.
+     my $retVal = $dbh->SQL($command, 0, @params);
+     # Make the funky zero a real zero.
+     if ($retVal == 0) {
+         $retVal = 0;
+     }
+     # Return the result.
+     return $retVal;
+ }
  =head2 Data Mining Methods
  =head3 GetUsefulCrossValues
- C<< my @attrNames = $sprout->GetUsefulCrossValues($sourceEntity, $relationship); >>
+     my @attrNames = $sprout->GetUsefulCrossValues($sourceEntity, $relationship);
  Return a list of the useful attributes that would be returned by a B<Cross> call
  from an entity of the source entity type through the specified relationship. This
-Line 3442
+Line 3937
  =head3 FindColumn
- C<< my $colIndex = ERDB::FindColumn($headerLine, $columnIdentifier); >>
+     my $colIndex = ERDB::FindColumn($headerLine, $columnIdentifier);
  Return the location a desired column in a data mining header line. The data
  mining header line is a tab-separated list of column names. The column
-Line 3500
+Line 3995
  =head3 ParseColumns
- C<< my @columns = ERDB::ParseColumns($line); >>
+     my @columns = ERDB::ParseColumns($line);
  Convert the specified data line to a list of columns.
-Line 3532
+Line 4027
  =head2 Virtual Methods
+ =head3 _CreatePPOIndex
+     my $index = ERDB::_CreatePPOIndex($indexObject);
+ Convert the XML for an ERDB index to the XML structure for a PPO
+ index.
+ =over 4
+ =item indexObject
+ ERDB XML structure for an index.
+ =item RETURN
+ PPO XML structure for the same index.
+ =back
+ =cut
+ sub _CreatePPOIndex {
+     # Get the parameters.
+     my ($indexObject) = @_;
+     # The incoming index contains a list of the index fields in the IndexFields
+     # member. We loop through it to create the index tags.
+     my @fields = map { { label => _FixName($_->{name}) } } @{$indexObject->{IndexFields}};
+     # Wrap the fields in attribute tags.
+     my $retVal = { attribute => \@fields };
+     # Return the result.
+     return $retVal;
+ }
+ =head3 _CreatePPOField
+     my $fieldXML = ERDB::_CreatePPOField($fieldName, $fieldObject);
+ Convert the ERDB XML structure for a field to a PPO scalar XML structure.
+ =over 4
+ =item fieldName
+ Name of the scalar field.
+ =item fieldObject
+ ERDB XML structure describing the field.
+ =item RETURN
+ Returns a PPO XML structure for the same field.
+ =back
+ =cut
+ sub _CreatePPOField {
+     # Get the parameters.
+     my ($fieldName, $fieldObject) = @_;
+     # Get the field type.
+     my $type = $TypeTable{$fieldObject->{type}}->{sqlType};
+     # Fix up the field name.
+     $fieldName = _FixName($fieldName);
+     # Build the scalar tag.
+     my $retVal = { label => $fieldName, type => $type };
+     # Return the result.
+     return $retVal;
+ }
  =head3 CleanKeywords
- C<< my $cleanedString = $erdb->CleanKeywords($searchExpression); >>
+     my $cleanedString = $erdb->CleanKeywords($searchExpression);
  Clean up a search expression or keyword list. This is a virtual method that may
  be overridden by the subclass. The base-class method removes extra spaces
-Line 3571
+Line 4136
  =head3 GetSourceObject
- C<< my $source = $erdb->GetSourceObject($entityName); >>
+     my $source = $erdb->GetSourceObject($entityName);
  Return the object to be used in loading special attributes of the specified entity. The
  algorithm for loading special attributes is stored in the C<DataGen> elements of the
-Line 3581
+Line 4146
  =head3 _RelationMap
- C<< my @relationMap = _RelationMap($mappedNameHashRef, $mappedNameListRef); >>
+     my @relationMap = _RelationMap($mappedNameHashRef, $mappedNameListRef);
- Create the relation map for an SQL query. The relation map is used by B<DBObject>
+ Create the relation map for an SQL query. The relation map is used by B<ERDBObject>
  to determine how to interpret the results of the query.
  =over 4
-Line 3600
+Line 4165
  =item RETURN
  Returns a list of 2-tuples. Each tuple consists of an object name as used in the
- query followed by the actual name of that object. This enables the B<DBObject> to
+ query followed by the actual name of that object. This enables the B<ERDBObject> to
  determine the order of the tables in the query and which object name belongs to each
  mapped object name. Most of the time these two values are the same; however, if a
  relation occurs twice in the query, the relation name in the field list and WHERE
-Line 3894
+Line 4459
  sub _GetStatementHandle {
      # Get the parameters.
      my ($self, $command, $params) = @_;
+     Confess("Invalid parameter list.") if (! defined($params) || ref($params) ne 'ARRAY');
      # Trace the query.
      Trace("SQL query: $command") if T(SQL => 3);
      Trace("PARMS: '" . (join "', '", @{$params}) . "'") if (T(SQL => 4) && (@{$params} > 0));
-Line 4131
+Line 4697
      # be a null string.
      if ($fileName ne "") {
          # Load the relation from the file.
-         $retVal = $self->LoadTable($fileName, $relationName, $rebuild);
+         $retVal = $self->LoadTable($fileName, $relationName, truncate => $rebuild);
      } elsif ($rebuild) {
          # Here we are rebuilding, but no file exists, so we just re-create the table.
          $self->CreateTable($relationName, 1);
-Line 4143
+Line 4709
  =head3 _LoadMetaData
- C<< my $metadata = ERDB::_LoadMetaData($filename); >>
+     my $metadata = ERDB::_LoadMetaData($filename);
  This method loads the data describing this database from an XML file into a metadata structure.
  The resulting structure is a set of nested hash tables containing all the information needed to
-Line 4501
+Line 5067
  =head3 _ProcessIndexes
- C<< ERDB::_ProcessIndexes($indexList, $relation); >>
+     ERDB::_ProcessIndexes($indexList, $relation);
  Build the data structures for the specified indexes in the specified relation.
-Line 4878
+Line 5444
      return $retVal;
  }
- =head2 HTML Documentation Utility Methods
+ =head2 Documentation Utility Methods
  =head3 _ComputeRelationshipSentence
-Line 4910
+Line 5476
      # Get the parameters.
      my ($relationshipName, $relationshipStructure) = @_;
      # Format the relationship sentence.
-     my $result = "$relationshipStructure->{from} <b>$relationshipName</b> $relationshipStructure->{to}";
+     my $result = "$relationshipStructure->{from} $relationshipName $relationshipStructure->{to}";
      # Compute the arity.
      my $arityCode = $relationshipStructure->{arity};
      my $arity = $ArityTable{$arityCode};
-Line 4955
+Line 5521
      return $result;
  }
+ =head3 _WikiRelationTable
+ Generate the Wiki text for a particular relation. The relation's data will be formatted as a
+ table with three columns-- the field name, the field type, and the field description.
+ This is a static method.
+ =over 4
+ =item relationName
+ Name of the relation being formatted.
+ =item relationData
+ Hash containing the relation's fields and indexes.
+ =item RETURN
+ Returns a Wiki string that can be used to display the relation name and all of its fields.
+ =back
+ =cut
+ sub _WikiRelationTable {
+     # Get the parameters.
+     my ($relationName, $relationData) = @_;
+     # We'll create a list of lists in here, then call WikiTools::Table to
+     # convert it into a table.
+     my @rows = ();
+     # Push in the header row.
+     push @rows, [qw(Field Type Description)];
+     # Loop through the fields.
+     for my $field (@{$relationData->{Fields}}) {
+         # Create this field's row. We always have a name and type.
+         my @row = ($field->{name}, $field->{type});
+         # If we have a description, add it as the third column.
+         if (exists $field->{Notes}) {
+             push @row, WikiNote($field->{Notes}->{content});
+         }
+         # Push this row onto the table list.
+         push @rows, \@row;
+     }
+     # Store the rows as a Wiki table with a level-4 heading.
+     my $retVal = join("\n\n", WikiTools::Heading(4, "$relationName Table"),
+                       WikiTools::Table(@rows));
+     # Now we show the relation's indexes. These are formatted as another
+     # table.
+     @rows = ();
+     # Push in the header row.
+     push @rows, [qw(Index Unique Fields Notes)];
+     # Get the index hash.
+     my $indexTable = $relationData->{Indexes};
+     # Loop through the indexes. For an entity, there is always at least one index.
+     # For a relationship, there are at least two. The upshot is we don't need to
+     # worry about accidentally generating a frivolous table here.
+     for my $indexName (sort keys %$indexTable) {
+         my $indexData = $indexTable->{$indexName};
+         # Determine whether or not the index is unique.
+         my $unique = ((exists $indexData->{Unique} && $indexData->{Unique} eq "true") ?
+                       "yes" : "");
+         # Get the field list.
+         my $fields = join(', ', @{$indexData->{IndexFields}});
+         # Get the note text.
+         my $description = "";
+         if (my $note = $indexData->{Notes}) {
+             $description = WikiNote($note->{content});
+         }
+         # Format this row.
+         my @row = ($indexName, $unique, $fields, $description);
+         push @rows, \@row;
+     }
+     # Add the index list to the result.
+     $retVal .= "\n\n" . WikiTools::Table(@rows);
+ }
  =head3 _ShowRelationTable
  Generate the HTML string for a particular relation. The relation's data will be formatted as an HTML
-Line 5128
+Line 5771
      return $htmlString;
  }
+ =head3 _ObjectNotes
+     my @noteParagraphs = _ObjectNotes($objectData);
+ Return a list of the notes and asides for an entity or relationship in
+ Wiki format.
+ =over 4
+ =item objectData
+ The metadata for the desired entity or relationship.
+ =item RETURN
+ Returns a list of text paragraphs in Wiki markup form.
+ =back
+ =cut
+ sub _ObjectNotes {
+     # Get the parameters.
+     my ($objectData) = @_;
+     # Declare the return variable.
+     my @retVal;
+     # Loop through the types of notes.
+     for my $noteType (qw(Notes Asides)) {
+         my $text = $objectData->{$noteType};
+         if ($text) {
+             push @retVal, "", WikiNote($text->{content});
+         }
+     }
+     # Return the result.
+     return @retVal;
+ }
 ;

 Legend:



Removed from v.1.87
 


changed lines


 
Added in v.1.99
 Legend:



Removed from v.1.87
 


changed lines


 
Added in v.1.99
-Removed from v.1.87
+Added in v.1.99

MCS Webmaster	ViewVC Help
Powered by ViewVC 1.0.3