Diff of /Sprout/ERDB.pm

-revision 1.92, Mon Jun 11 18:51:23 2007 UTC
+revision 1.104, Mon Sep 22 20:33:30 2008 UTC
 Line 11
      use Time::HiRes qw(gettimeofday);
      use Digest::MD5 qw(md5_base64);
      use CGI;
+     use WikiTools;
  =head1 Entity-Relationship Database Package
-Line 101
+Line 102
  =item text
- long string; Text fields cannot be used in indexes or sorting and do not support the
+ long string; Text fields do not support the normal syntax of filter clauses,
- normal syntax of filter clauses, but can be up to a billion character in length
+ but can be up to a billion character in length
+ =item dna
+ long string, used to store DNA and protein sequences
+ =item image
+ long string, used to store encoded image data
  =item float
-Line 347
+Line 356
                                 indexMod =>   0, notes => "signed 32-bit integer"},
                    counter => { sqlType => 'INTEGER UNSIGNED',   maxLen => 20,           avgLen =>   4, sort => "n",
                                 indexMod =>   0, notes => "unsigned 32-bit integer"},
+                   image =>    { sqlType => 'TEXT',               maxLen => 1000000000,   avgLen => 100000, sort => "",
+                                indexMod => 255, notes => "UUencoded image, suitable for import into GD, should never be indexed"},
+                   dna =>      { sqlType => 'TEXT',               maxLen => 1000000000,   avgLen => 100000, sort => "",
+                                indexMod => 255, notes => "DNA or protein sequence, should never be indexed"},
                    string =>  { sqlType => 'VARCHAR(255)',       maxLen => 255,          avgLen => 100, sort => "",
                                 indexMod =>   0, notes => "character string, 0 to 255 characters"},
                    text =>    { sqlType => 'TEXT',               maxLen => 1000000000,   avgLen => 500, sort => "",
-Line 389
+Line 402
                                    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 408
+Line 424
                    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 433
+Line 448
  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 447
+Line 462
  =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 488
+Line 503
  =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 644
+Line 659
  =head3 DumpMetaData
- C<< $erdb->DumpMetaData(); >>
+     $erdb->DumpMetaData();
  Return a dump of the metadata structure.
-Line 657
+Line 672
      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
- C<< ERDB::CreatePPO($erdbXMLFile, $ppoXMLFile); >>
+     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
-Line 810
+Line 938
  =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 880
+Line 1008
  =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 904
+Line 1032
  =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 946
+Line 1074
          # Push the result into the field list.
          push @fieldList, $fieldString;
      }
-     # If this is a root table, add the "new_record" flag. It defaults to 0, so
-     if ($rootFlag) {
-         push @fieldList, "new_record $TypeTable{boolean}->{sqlType} NOT NULL DEFAULT 0";
-     }
      # Convert the field list into a comma-delimited string.
      my $fieldThing = join(', ', @fieldList);
      # Insure the table is not already there.
-Line 960
+Line 1084
      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 974
+Line 1099
  =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 1029
+Line 1154
  =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 1069
+Line 1194
  =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 1102
+Line 1227
  =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 1158
+Line 1283
  =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 1199
+Line 1324
  =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 1240
+Line 1365
  =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 1323
+Line 1448
  =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 1383
+Line 1508
  =head3 GetTableNames
- C<< my @names = $erdb->GetTableNames; >>
+     my @names = $erdb->GetTableNames;
  Return a list of the relations required to implement this database.
-Line 1400
+Line 1525
  =head3 GetEntityTypes
- C<< my @names = $erdb->GetEntityTypes; >>
+     my @names = $erdb->GetEntityTypes;
  Return a list of the entity type names.
-Line 1415
+Line 1540
      return sort keys %{$entityList};
  }
+ =head3 GetConnectingRelationships
+     my @list = $erdb->GetConnectingRelationships($entityName);
+ Return a list of the relationships connected to the specified entity.
+ =over 4
+ =item entityName
+ Entity whose connected relationships are desired.
+ =item RETURN
+ Returns a list of the relationships that originate from the entity.
+ If the entity is on the from end, it will return the relationship
+ name. If the entity is on the to end it will return the converse of
+ the relationship name.
+ =back
+ =cut
+ sub GetConnectingRelationships {
+     # Get the parameters.
+     my ($self, $entityName) = @_;
+     # Declare the return variable.
+     my @retVal;
+     # Get the relationship list.
+     my $relationships = $self->{_metaData}->{Relationships};
+     # Find the entity.
+     my $entity = $self->{_metaData}->{Entities}->{$entityName};
+     # Only proceed if the entity exists.
+     if (! defined $entity) {
+         Trace("Entity $entityName not found.") if T(3);
+     } else {
+         # Loop through the relationships.
+         my @rels = keys %$relationships;
+         Trace(scalar(@rels) . " relationships found in connection search.") if T(3);
+         for my $relationshipName (@rels) {
+             my $relationship = $relationships->{$relationshipName};
+             if ($relationship->{from} eq $entityName) {
+                 # Here we have a forward relationship.
+                 push @retVal, $relationshipName;
+             } elsif ($relationship->{to} eq $entityName) {
+                 # Here we have a backward relationship. In this case, the
+                 # converse relationship name is preferred if it exists.
+                 my $converse = $relationship->{converse} || $relationshipName;
+                 push @retVal, $converse;
+             }
+         }
+     }
+     # Return the result.
+     return @retVal;
+ }
  =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 1436
+Line 1619
  =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 1463
+Line 1646
  =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 1471
+Line 1654
  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 1488
+Line 1671
  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 1524
+Line 1707
  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 1537
+Line 1720
  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 1564
+Line 1747
      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 1582
+Line 1765
  =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 1665
+Line 1848
              $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 1679
+Line 1862
  =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 1732
+Line 1915
  =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 1774
+Line 1957
  =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 1959
+Line 2142
  =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 1998
+Line 2181
          # 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 2013
+Line 2206
  =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 2068
+Line 2261
  =head3 DeleteLike
- C<< my $deleteCount = $erdb->DeleteLike($relName, $filter, \@parms); >>
+     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.
-Line 2133
+Line 2326
  =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 2189
+Line 2382
      }
      # Now we parse the key names into sort parameters. First, we prime the return
      # string.
-     my $retVal = "sort -t\"\t\" ";
+     my $retVal = "sort -S 1G -T\"$FIG_Config::temp\" -t\"\t\" ";
      # Get the relation's field list.
      my @fields = @{$relationData->{Fields}};
      # Loop through the keys.
-Line 2219
+Line 2412
                  # will stop the inner loop. Note that the field number is
                  # 1-based in the sort command, so we have to increment the
                  # index.
-                 $fieldSpec = ($i + 1) . $modifier;
+                 my $realI = $i + 1;
+                 $fieldSpec = "$realI,$realI$modifier";
              }
          }
          # Add this field to the sort command.
-Line 2231
+Line 2425
  =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 2259
+Line 2453
  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 2294
+Line 2488
  =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 2387
+Line 2581
  =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 2422
+Line 2616
  =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 2464
+Line 2658
  =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 2527
+Line 2721
  =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 2536
+Line 2730
  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 2610
+Line 2804
                  push @missing, $fieldName;
              }
          }
-         # If we are the primary relation, add the new-record flag.
-         if ($relationName eq $newObjectType) {
-             push @valueList, 1;
-             push @fieldNameList, "new_record";
-         }
          # Only proceed if there are no missing fields.
          if (@missing > 0) {
              Trace("Relation $relationName for $newObjectType skipped due to missing fields: " .
-Line 2664
+Line 2853
  =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 2722
+Line 2911
  =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 2737
+Line 2926
  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 2747
+Line 2936
  =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 2762
+Line 2971
      # 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 = $fileSize * 1.5 / $rowSize;
+         my $estimate = $fileSize * 8 / $rowSize;
          if ($estimate < 1000) {
              $estimate = 1000;
          }
-Line 2788
+Line 2997
      # 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 2799
+Line 3008
          $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 2821
+Line 3031
          }
      }
      # Analyze the table to improve performance.
+     if (! $options{partial}) {
      Trace("Analyzing and compacting $relationName.") if T(3);
-     $dbh->vacuum_it($relationName);
+         $self->Analyze($relationName);
+     }
      Trace("$relationName load completed.") if T(3);
      # Return the statistics.
      return $retVal;
  }
+ =head3 Analyze
+     $erdb->Analyze($tableName);
+ Analyze and compact a table in the database. This is useful after a load
+ to improve the performance of the indexes.
+ =over 4
+ =item tableName
+ Name of the table to be analyzed and compacted.
+ =back
+ =cut
+ sub Analyze {
+     # Get the parameters.
+     my ($self, $tableName) = @_;
+     # Analyze the table.
+     $self->{_dbh}->vacuum_it($tableName);
+ }
+ =head3 TruncateTable
+     $erdb->TruncateTable($table);
+ Delete all rows from a table quickly. This uses the built-in SQL
+ C<TRUNCATE> statement, which effectively drops and re-creates a table
+ with all its settings intact.
+ =over 4
+ =item table
+ Name of the table to be cleared.
+ =back
+ =cut
+ sub TruncateTable {
+     # Get the parameters.
+     my ($self, $table) = @_;
+     # Get the database handle.
+     my $dbh = $self->{_dbh};
+     # Execute a truncation comment.
+     $dbh->SQL("TRUNCATE TABLE $table");
+ }
  =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 2867
+Line 3131
  =head3 DropRelation
- C<< $erdb->DropRelation($relationName); >>
+     $erdb->DropRelation($relationName);
  Physically drop a relation from the database.
-Line 2895
+Line 3159
  =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 2978
+Line 3242
  =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 3008
+Line 3272
      my $query = $self->Get([$entityType], "$entityType(id) = ?", [$ID]);
      # Get the first (and only) object.
      my $retVal = $query->Fetch();
+     if (T(3)) {
+         if ($retVal) {
+             Trace("Entity $entityType \"$ID\" found.");
+         } else {
+             Trace("Entity $entityType \"$ID\" not found.");
+         }
+     }
      # Return the result.
      return $retVal;
  }
  =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 3069
+Line 3340
  =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 3113
+Line 3384
  =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 3129
+Line 3400
  spreadsheet cell, and each feature will be represented by a list containing the
  feature ID followed by all of its essentiality determinations.
- C<< @query = $erdb->Get(['ContainsFeature', 'Feature'], "ContainsFeature(from-link) = ?", [$ssCellID], ['Feature(id)', 'Feature(essential)']); >>
+     @query = $erdb->Get(['ContainsFeature', 'Feature'], "ContainsFeature(from-link) = ?", [$ssCellID], ['Feature(id)', 'Feature(essential)']);
  =over 4
-Line 3200
+Line 3471
          push @retVal, \@rowData;
          $fetched++;
      }
-     Trace("$fetched rows returned in GetAll.") if T(SQL => 4);
      # Return the resulting list.
      return @retVal;
  }
  =head3 Exists
- C<< my $found = $sprout->Exists($entityName, $entityID); >>
+     my $found = $sprout->Exists($entityName, $entityID);
  Return TRUE if an entity exists, else FALSE.
-Line 3242
+Line 3512
  =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 3280
+Line 3550
  =head3 GetFieldTable
- C<< my $fieldHash = $self->GetFieldTable($objectnName); >>
+     my $fieldHash = $self->GetFieldTable($objectnName);
  Get the field structure for a specified entity or relationship.
-Line 3309
+Line 3579
  =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 3358
+Line 3628
  =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 3413
+Line 3683
  =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 3446
+Line 3716
  =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 3488
+Line 3758
  =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 3527
+Line 3797
  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 3557
+Line 3827
      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 3573
+Line 3890
  =head3 CommitTran
- C<< $erdb->CommitTran(); >>
+     $erdb->CommitTran();
  Commit an active database transaction.
-Line 3586
+Line 3903
  =head3 RollbackTran
- C<< $erdb->RollbackTran(); >>
+     $erdb->RollbackTran();
  Roll back an active database transaction.
-Line 3599
+Line 3916
  =head3 UpdateField
- C<< my $count = $erdb->UpdateField($objectNames, $fieldName, $oldValue, $newValue, $filter, $parms); >>
+     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.
-Line 3679
+Line 3996
  =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 3740
+Line 4057
  =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 3798
+Line 4115
  =head3 ParseColumns
- C<< my @columns = ERDB::ParseColumns($line); >>
+     my @columns = ERDB::ParseColumns($line);
  Convert the specified data line to a list of columns.
-Line 3832
+Line 4149
  =head3 _CreatePPOIndex
- C<< my $index = ERDB::_CreatePPOIndex($indexObject); >>
+     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
-Line 3863
+Line 4182
  =head3 _CreatePPOField
- C<< my $fieldXML = ERDB::_CreatePPOField($fieldName, $fieldObject); >>
+     my $fieldXML = ERDB::_CreatePPOField($fieldName, $fieldObject);
  Convert the ERDB XML structure for a field to a PPO scalar XML structure.
-Line 3900
+Line 4219
  =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 3937
+Line 4256
  =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 3947
+Line 4266
  =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<ERDBObject>
  to determine how to interpret the results of the query.
-Line 4260
+Line 4579
  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 4497
+Line 4817
      # 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 4509
+Line 4829
  =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 4867
+Line 5187
  =head3 _ProcessIndexes
- C<< ERDB::_ProcessIndexes($indexList, $relation); >>
+     ERDB::_ProcessIndexes($indexList, $relation);
  Build the data structures for the specified indexes in the specified relation.
-Line 5244
+Line 5564
      return $retVal;
  }
- =head2 HTML Documentation Utility Methods
+ =head2 Documentation Utility Methods
  =head3 _ComputeRelationshipSentence
-Line 5276
+Line 5596
      # 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 5321
+Line 5641
      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 5494
+Line 5891
      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.92
 


changed lines


 
Added in v.1.104
 Legend:



Removed from v.1.92
 


changed lines


 
Added in v.1.104
-Removed from v.1.92
+Added in v.1.104

MCS Webmaster	ViewVC Help
Powered by ViewVC 1.0.3