Diff of /Sprout/CustomAttributes.pm

-revision 1.9, Thu Nov 16 22:09:33 2006 UTC
+revision 1.17, Thu Jan 25 02:41:12 2007 UTC
 Line 8
      use strict;
      use Tracer;
      use ERDBLoad;
+     use Stats;
  =head1 Custom SEED Attribute Manager
-Line 15
+Line 16
  The Custom SEED Attributes Manager allows the user to upload and retrieve
  custom data for SEED objects. It uses the B<ERDB> database system to
- store the attributes, which are implemented as multi-valued fields
+ store the attributes.
- of ERDB entities.
+ Attributes are organized by I<attribute key>. Attribute values are
+ assigned to I<objects>. In the real world, objects have types and IDs;
+ however, to the attribute database only the ID matters. This will create
+ a problem if we have a single ID that applies to two objects of different
+ types, but it is more consistent with the original attribute implementation
+ in the SEED (which this implementation replaces).
+ The actual attribute values are stored as a relationship between the attribute
+ keys and the objects. There can be multiple values for a single key/object pair.
  The full suite of ERDB retrieval capabilities is provided. In addition,
  custom methods are provided specific to this application. To get all
  the values of the attribute C<essential> in a specified B<Feature>, you
  would code
-     my @values = $attrDB->GetAttributes([Feature => $fid], 'essential');
+     my @values = $attrDB->GetAttributes($fid, 'essential');
- where I<$fid> contains the ID of the desired feature. Each attribute has
+ where I<$fid> contains the ID of the desired feature.
- an alternate index to allow searching for attributes by value.
- New attributes are introduced by updating the database definition at
+ New attribute keys must be defined before they can be used. A web interface
- run-time. Attribute values are stored by uploading data from files.
+ is provided for this purpose.
- A web interface is provided for both these activities.
  =head2 FIG_Config Parameters
-Line 76
+Line 84
  =back
- The DBD file is critical, and must have reasonable contents before we can
- begin using the system. In the old system, attributes were only provided
- for Genomes and Features, so the initial XML file was the following.
-     <Database>
-       <Title>SEED Custom Attribute Database</Title>
-       <Entities>
-         <Entity name="Feature" keyType="id-string">
-           <Notes>A [i]feature[/i] is a part of the genome
-           that is of special interest. Features may be spread
-           across multiple contigs of a genome, but never across
-           more than one genome. Features can be assigned to roles
-           via spreadsheet cells, and are the targets of
-           annotation.</Notes>
-         </Entity>
-         <Entity name="Genome" keyType="name-string">
-           <Notes>A [i]genome[/i] describes a particular individual
-           organism's DNA.</Notes>
-         </Entity>
-       </Entities>
-     </Database>
- It is not necessary to put any tables into the database; however, you should
- run
-     AttrDBRefresh
- periodically to insure it has the correct Genomes and Features in it. When
- converting from the old system, use
-     AttrDBRefresh -migrate
- to initialize the database and migrate the legacy data. You should only need
- to do that once.
- =head2 Implementation Note
- The L</Refresh> method reloads the entities in the database. If new
- entity types are added, that method will need to be adjusted accordingly.
  =head2 Public Methods
  =head3 new
  C<< my $attrDB = CustomAttributes->new($splitter); >>
- Construct a new CustomAttributes object. This object cannot be used to add or
+ Construct a new CustomAttributes object.
- delete keys because that requires modifying the database design. To do that,
- you need to use the static L</StoreAttributeKey> or L</DeleteAttributeKey>
- methods.
  =over 4
-Line 159
+Line 124
  =head3 StoreAttributeKey
- C<< my $attrDB = CustomAttributes::StoreAttributeKey($entityName, $attributeName, $type, $notes); >>
+ C<< $attrDB->StoreAttributeKey($attributeName, $type, $notes, \@groups); >>
- Create or update an attribute for the database. This method will update the database definition
+ Create or update an attribute for the database.
- XML, but it will not create the table. It will connect to the database so that the caller
- can upload the attribute values.
  =over 4
- =item entityName
- Name of the entity containing the attribute. The entity must exist.
  =item attributeName
  Name of the attribute. It must be a valid ERDB field name, consisting entirely of
-Line 185
+Line 144
  Descriptive notes about the attribute. It is presumed to be raw text, not HTML.
- =item RETURN
+ =item groups
- Returns a Custom Attribute Database object if successful. If unsuccessful, an
+ Reference to a list of the groups to which the attribute should be associated.
- error will be thrown.
+ This will replace any groups to which the attribute is currently attached.
  =back
-Line 196
+Line 155
  sub StoreAttributeKey {
      # Get the parameters.
-     my ($entityName, $attributeName, $type, $notes) = @_;
+     my ($self, $attributeName, $type, $notes, $groups) = @_;
      # Declare the return variable.
      my $retVal;
      # Get the data type hash.
-Line 208
+Line 167
          Confess("Missing or incomplete description for $attributeName.");
      } elsif (! exists $types{$type}) {
          Confess("Invalid data type \"$type\" for $attributeName.");
-     }
-     # Our next step is to read in the XML for the database defintion. We
-     # need to verify that the named entity exists.
-     my $metadata = ERDB::ReadMetaXML($FIG_Config::attrDBD);
-     my $entityHash = $metadata->{Entities};
-     if (! exists $entityHash->{$entityName}) {
-         Confess("Entity $entityName not found.");
      } else {
-         # Okay, we're ready to begin. Get the entity hash and the field hash.
+         # Okay, we're ready to begin. See if this key exists.
-         my $entityData = $entityHash->{$entityName};
+         my $attribute = $self->GetEntity('AttributeKey', $attributeName);
-         my $fieldHash = ERDB::GetEntityFieldHash($metadata, $entityName);
+         if (defined($attribute)) {
-         # Compare the old attribute data to the new data.
+             # It does, so we do an update.
-         my $bigChange = 1;
+             $self->UpdateEntity('AttributeKey', $attributeName,
-         if (exists $fieldHash->{$attributeName} && $fieldHash->{$attributeName}->{type} eq $type) {
+                                 { description => $notes, 'data-type' => $type });
-             $bigChange = 0;
+             # Detach the key from its current groups.
-         }
+             $self->Disconnect('IsInGroup', 'AttributeKey', $attributeName);
-         # Compute the attribute's relation name.
+         } else {
-         my $relName = join("", $entityName, map { ucfirst $_ } split(/-|_/, $attributeName));
+             # It doesn't, so we do an insert.
-         # Store the attribute's field data. Note the use of the "content" hash for
+             $self->InsertObject('AttributeKey', { id => $attributeName,
-         # the notes. This is how the XML writer knows Notes is a text tag instead of
+                                 description => $notes, 'data-type' => $type });
-         # an attribute.
+         }
-         $fieldHash->{$attributeName} = { type => $type, relation => $relName,
+         # Attach the key to the specified groups. (We presume the groups already
-                                          Notes => { content => $notes } };
+         # exist.)
-         # Insure we have an index for this attribute.
+         for my $group (@{$groups}) {
-         my $index = ERDB::FindIndexForEntity($metadata, $entityName, $attributeName);
+             $self->InsertObject('IsInGroup', { 'from-link' => $attributeName,
-         if (! defined($index)) {
+                                                'to-link'   => $group });
-             push @{$entityData->{Indexes}}, { IndexFields => [ { name => $attributeName, order => 'ascending' } ],
-                                               Notes       => "Alternate index provided for access by $attributeName." };
-         }
-         # Write the XML back out.
-         ERDB::WriteMetaXML($metadata, $FIG_Config::attrDBD);
-         # Open a database with the new XML.
-         $retVal = CustomAttributes->new();
-         # Create the table if there has been a significant change.
-         if ($bigChange) {
-             $retVal->CreateTable($relName);
-         }
-     }
-     return $retVal;
- }
- =head3 Refresh
- C<< $attrDB->Refresh($fig); >>
- Refresh the primary entity tables from the FIG data store. This method basically
- drops and reloads the main tables of the custom attributes database.
- =over 4
- =item fig
- FIG-like object that can be used to find genomes and features.
- =back
- =cut
- sub Refresh {
-     # Get the parameters.
-     my ($self, $fig) = @_;
-     # Create load objects for the genomes and the features.
-     my $loadGenome = ERDBLoad->new($self, 'Genome', $FIG_Config::temp);
-     my $loadFeature = ERDBLoad->new($self, 'Feature', $FIG_Config::temp);
-     # Get the genome list.
-     my @genomes = $fig->genomes();
-     # Loop through the genomes.
-     for my $genomeID (@genomes) {
-         # Put this genome in the genome table.
-         $loadGenome->Put($genomeID);
-         Trace("Processing Genome $genomeID") if T(3);
-         # Put its features into the feature table. Note we have to use a hash to
-         # remove duplicates.
-         my %featureList = map { $_ => 1 } $fig->all_features($genomeID);
-         for my $fid (keys %featureList) {
-             $loadFeature->Put($fid);
          }
      }
-     # Get a variable for holding statistics objects.
-     my $stats;
-     # Finish the genome load.
-     Trace("Loading Genome relation.") if T(2);
-     $stats = $loadGenome->FinishAndLoad();
-     Trace("Genome table load statistics:\n" . $stats->Show()) if T(3);
-     # Finish the feature load.
-     Trace("Loading Feature relation.") if T(2);
-     $stats = $loadFeature->FinishAndLoad();
-     Trace("Feature table load statistics:\n" . $stats->Show()) if T(3);
  }
  =head3 LoadAttributeKey
- C<< my $stats = $attrDB->LoadAttributeKey($entityName, $fieldName, $fh, $keyCol, $dataCol); >>
+ C<< my $stats = $attrDB->LoadAttributeKey($keyName, $fh, $keyCol, $dataCol, %options); >>
  Load the specified attribute from the specified file. The file should be a
  tab-delimited file with internal tab and new-line characters escaped. This is
  the typical TBL-style file used by most FIG applications. One of the columns
- in the input file must contain the appropriate key value and the other the
+ in the input file must contain the appropriate object id value and the other the
  corresponding attribute value.
  =over 4
- =item entityName
+ =item keyName
- Name of the entity containing the attribute.
- =item fieldName
+ Key of the attribute to load.
- Name of the actual attribute.
  =item fh
  Open file handle for the input file.
- =item keyCol
+ =item idCol
- Index (0-based) of the column containing the key field. The key field should
+ Index (0-based) of the column containing the ID field. The ID field should
  contain the ID of an instance of the named entity.
  =item dataCol
  Index (0-based) of the column containing the data value field.
+ =item options
+ Hash specifying the options for this load.
  =item RETURN
  Returns a statistics object for the load process.
  =back
+ The available options are as follows.
+ =over 4
+ =item erase
+ If TRUE, the key's values will all be erased before loading. (Doing so
+ makes for a faster load.)
+ =back
  =cut
  sub LoadAttributeKey {
      # Get the parameters.
-     my ($self, $entityName, $fieldName, $fh, $keyCol, $dataCol) = @_;
+     my ($self, $keyName, $fh, $idCol, $dataCol, %options) = @_;
      # Create the return variable.
-     my $retVal;
+     my $retVal = Stats->new("lineIn", "shortLine", "newObject");
-     # Insure the entity exists.
+     # Compute the minimum number of fields required in each input line.
-     my $found = grep { $_ eq $entityName } $self->GetEntityTypes();
+     my $minCols = ($idCol < $dataCol ? $idCol : $idCol) + 1;
-     if (! $found) {
+     # Insure the attribute key exists.
-         Confess("Entity \"$entityName\" not found in database.");
+     my $found = $self->GetEntity('AttributeKey', $keyName);
-     } else {
+     if (! defined $found) {
-         # Get the field structure for the named entity.
+         Confess("Attribute key \"$keyName\" not found in database.");
-         my $fieldHash = $self->GetFieldTable($entityName);
-         # Verify that the attribute exists.
-         if (! exists $fieldHash->{$fieldName}) {
-             Confess("Attribute key \"$fieldName\" does not exist in entity $entityName.");
          } else {
-             # Create a loader for the specified attribute. We need the
+         # Erase the key's current values.
-             # relation name first.
+         $self->EraseAttribute($keyName);
-             my $relName = $fieldHash->{$fieldName}->{relation};
+         # Save a list of the object IDs we need to add.
-             my $loadAttribute = ERDBLoad->new($self, $relName, $FIG_Config::temp);
+         my %objectIDs = ();
              # Loop through the input file.
              while (! eof $fh) {
                  # Get the next line of the file.
                  my @fields = Tracer::GetLine($fh);
-                 $loadAttribute->Add("lineIn");
+             $retVal->Add(lineIn => 1);
                  # Now we need to validate the line.
-                 if ($#fields < $dataCol) {
+             if (scalar(@fields) < $minCols) {
-                     $loadAttribute->Add("shortLine");
+                 $retVal->Add(shortLine => 1);
-                 } elsif (! $self->Exists($entityName, $fields[$keyCol])) {
-                     $loadAttribute->Add("badKey");
                  } else {
-                     # It's valid,so send it to the loader.
+                 # It's valid, so get the ID and value.
-                     $loadAttribute->Put($fields[$keyCol], $fields[$dataCol]);
+                 my ($id, $value) = ($fields[$idCol], $fields[$dataCol]);
-                     $loadAttribute->Add("lineUsed");
+                 # Denote we're using this input line.
+                 $retVal->Add(lineUsed => 1);
+                 # Now we insert the attribute.
+                 $self->InsertObject('HasValueFor', { from => $keyName, to => $id,
+                                                      value => $value });
+                 $retVal->Add(newValue => 1);
                  }
              }
-             # Finish the load.
-             $retVal = $loadAttribute->FinishAndLoad();
-         }
      }
      # Return the statistics.
      return $retVal;
-Line 386
+Line 285
  =head3 DeleteAttributeKey
- C<< CustomAttributes::DeleteAttributeKey($entityName, $attributeName); >>
+ C<< my $stats = $attrDB->DeleteAttributeKey($attributeName); >>
  Delete an attribute from the custom attributes database.
  =over 4
- =item entityName
- Name of the entity possessing the attribute.
  =item attributeName
  Name of the attribute to delete.
+ =item RETURN
+ Returns a statistics object describing the effects of the deletion.
  =back
  =cut
  sub DeleteAttributeKey {
      # Get the parameters.
-     my ($entityName, $attributeName) = @_;
+     my ($self, $attributeName) = @_;
-     # Read in the XML for the database defintion. We need to verify that
+     # Delete the attribute key.
-     # the named entity exists and it has the named attribute.
+     my $retVal = $self->Delete('AttributeKey', $attributeName);
-     my $metadata = ERDB::ReadMetaXML($FIG_Config::attrDBD);
+     # Return the result.
-     my $entityHash = $metadata->{Entities};
+     return $retVal;
-     if (! exists $entityHash->{$entityName}) {
-         Confess("Entity \"$entityName\" not found.");
-     } else {
-         # Get the field hash.
-         my $fieldHash = ERDB::GetEntityFieldHash($metadata, $entityName);
-         if (! exists $fieldHash->{$attributeName}) {
-             Confess("Attribute key \"$attributeName\" not found in entity $entityName.");
-         } else {
-             # Get the attribute's relation name.
-             my $relName = $fieldHash->{$attributeName}->{relation};
-             # Check for an index.
-             my $indexIdx = ERDB::FindIndexForEntity($metadata, $entityName, $attributeName);
-             if (defined($indexIdx)) {
-                 Trace("Index for $attributeName found at position $indexIdx for $entityName.") if T(3);
-                 delete $entityHash->{$entityName}->{Indexes}->[$indexIdx];
-             }
-             # Delete the attribute from the field hash.
-             Trace("Deleting attribute $attributeName from $entityName.") if T(3);
-             delete $fieldHash->{$attributeName};
-             # Write the XML back out.
-             ERDB::WriteMetaXML($metadata, $FIG_Config::attrDBD);
-             # Insure the relation does not exist in the database. This requires connecting
-             # since we may have to do a table drop.
-             my $attrDB = CustomAttributes->new();
-             Trace("Dropping table $relName.") if T(3);
-             $attrDB->DropRelation($relName);
-         }
      }
+ =head3 NewName
+ C<< my $text = CustomAttributes::NewName(); >>
+ Return the string used to indicate the user wants to add a new attribute.
+ =cut
+ sub NewName {
+     return "(new)";
  }
  =head3 ControlForm
- C<< my $formHtml = $attrDB->ControlForm($cgi, $name); >>
+ C<< my $formHtml = $attrDB->ControlForm($cgi, $name, \%keys); >>
  Return a form that can be used to control the creation and modification of
- attributes.
+ attributes. Only a subset of the attribute keys will be displayed, as
+ determined by the incoming list.
  =over 4
-Line 458
+Line 343
  Name to give to the form. This should be unique for the web page.
+ =item keys
+ Reference to a hash mapping attribute keys to n-tuples. Each tuple will contain the
+ attribute's data type, its description, and a list of the groups in which it participates.
  =item RETURN
- Returns the HTML for a form that submits instructions to the C<Attributes.cgi> script
+ Returns the HTML for a form that can be used to  submit instructions to the C<Attributes.cgi> script
- for loading, creating, or deleting an attribute.
+ for loading, creating, displaying, changing, or deleting an attribute. Note that only the form
+ controls are generated. The form tags are left to the caller.
  =back
-Line 469
+Line 360
  sub ControlForm {
      # Get the parameters.
-     my ($self, $cgi, $name) = @_;
+     my ($self, $cgi, $name, $keys) = @_;
      # Declare the return list.
      my @retVal = ();
-     # Start the form. We use multipart to support the upload control.
-     push @retVal, $cgi->start_multipart_form(-name => $name);
      # We'll put the controls in a table. Nothing else ever seems to look nice.
      push @retVal, $cgi->start_table({ border => 2, cellpadding => 2 });
      # The first row is for selecting the field name.
      push @retVal, $cgi->Tr($cgi->th("Select a Field"),
-                            $cgi->td($self->FieldMenu($cgi, 10, 'fieldName', 1,
+                            $cgi->td($self->FieldMenu($cgi, 10, 'fieldName', $keys,
-                                                      "document.$name.notes.value",
+                                                      new => 1,
-                                                      "document.$name.dataType.value")));
+                                                      notes => "document.$name.notes.value",
+                                                      type => "document.$name.dataType.value",
+                                                      groups => "document.$name.groups")));
      # Now we set up a dropdown for the data types. The values will be the
      # data type names, and the labels will be the descriptions.
      my %types = ERDB::GetDataTypes();
      my %labelMap = map { $_ => $types{$_}->{notes} } keys %types;
      my $typeMenu = $cgi->popup_menu(-name   => 'dataType',
                                      -values => [sort keys %types],
-                                     -labels => \%labelMap);
+                                     -labels => \%labelMap,
+                                     -default => 'string');
+     # Allow the user to specify a new field name. This is required if the
+     # user has selected the "(new)" marker. We put a little scriptlet in here that
+     # selects the (new) marker when the user enters the field.
+     push @retVal, "<script language=\"javaScript\">";
+     my $fieldField = "document.$name.fieldName";
+     my $newName = "\"" . NewName() . "\"";
+     push @retVal, $cgi->Tr($cgi->th("New Field Name"),
+                            $cgi->td($cgi->textfield(-name => 'newName',
+                                                     -size => 30,
+                                                     -value => "",
+                                                     -onFocus => "setIfEmpty($fieldField, $newName);")),
+                                     );
      push @retVal, $cgi->Tr($cgi->th("Data type"),
                             $cgi->td($typeMenu));
      # The next row is for the notes.
-Line 496
+Line 400
                                                     -rows => 6,
                                                     -columns => 80))
                            );
-     # Allow the user to specify a new field name. This is required if the
+     # Now we have the groups, which are implemented as a checkbox group.
-     # user has selected one of the "(new)" markers.
+     my @groups = $self->GetGroups();
-     push @retVal, $cgi->Tr($cgi->th("New Field Name"),
+     push @retVal, $cgi->Tr($cgi->th("Groups"),
-                            $cgi->td($cgi->textfield(-name => 'newName',
+                            $cgi->td($cgi->checkbox_group(-name=>'groups',
-                                                     -size => 30)),
+                                     -values=> \@groups))
                                      );
      # If the user wants to upload new values for the field, then we have
      # an upload file name and column indicators.
-Line 517
+Line 421
                                                      -default => 1)
                                     ),
                            );
-     # Now the three buttons: UPDATE, SHOW, and DELETE.
+     # Now the three buttons: STORE, SHOW, and DELETE.
      push @retVal, $cgi->Tr($cgi->th("&nbsp;"),
                             $cgi->td({align => 'center'},
                                      $cgi->submit(-name => 'Delete', -value => 'DELETE') . " " .
-Line 527
+Line 431
                            );
      # Close the table and the form.
      push @retVal, $cgi->end_table();
-     push @retVal, $cgi->end_form();
      # Return the assembled HTML.
      return join("\n", @retVal, "");
  }
+ =head3 LoadAttributesFrom
+ C<< my $stats = $attrDB->LoadAttributesFrom($fileName, %options); >>
+ Load attributes from the specified tab-delimited file. Each line of the file must
+ contain an object ID in the first column, an attribute key name in the second
+ column, and attribute values in the remaining columns. The attribute values will
+ be assembled into a single value using the splitter code.
+ =over 4
+ =item fileName
+ Name of the file from which to load the attributes.
+ =item options
+ Hash of options for modifying the load process.
+ =item RETURN
+ Returns a statistics object describing the load.
+ =back
+ Permissible option values are as follows.
+ =over 4
+ =item append
+ If TRUE, then the attributes will be appended to existing data; otherwise, the
+ first time a key name is encountered, it will be erased.
+ =back
+ =cut
+ sub LoadAttributesFrom {
+     # Get the parameters.
+     my ($self, $fileName, %options) = @_;
+     # Declare the return variable.
+     my $retVal = Stats->new('keys', 'values');
+     # Check for append mode.
+     my $append = ($options{append} ? 1 : 0);
+     # Create a hash of key names found.
+     my %keyHash = ();
+     # Open the file for input.
+     my $fh = Open(undef, "<$fileName");
+     # Loop through the file.
+     while (! eof $fh) {
+         my ($id, $key, @values) = Tracer::GetLine($fh);
+         $retVal->Add(linesIn => 1);
+         # Do some validation.
+         if (! defined($id)) {
+             # We ignore blank lines.
+             $retVal->Add(blankLines => 1);
+         } elsif (! defined($key)) {
+             # An ID without a key is a serious error.
+             my $lines = $retVal->Ask('linesIn');
+             Confess("Line $lines in $fileName has no attribute key.");
+         } else {
+             # Now we need to check for a new key.
+             if (! exists $keyHash{$key}) {
+                 # This is a new key. Verify that it exists.
+                 if (! $self->Exists('AttributeKey', $key)) {
+                     my $line = $retVal->Ask('linesIn');
+                     Confess("Attribute \"$key\" on line $line of $fileName not found in database.");
+                 } else {
+                     # Make sure we know this is no longer a new key.
+                     $keyHash{$key} = 1;
+                     $retVal->Add(keys => 1);
+                     # If this is NOT append mode, erase the key.
+                     if (! $append) {
+                         $self->EraseAttribute($key);
+                     }
+                 }
+                 Trace("Key $key found.") if T(3);
+             }
+             # Now we know the key is valid. Add this value.
+             $self->AddAttribute($id, $key, @values);
+             my $progress = $retVal->Add(values => 1);
+             Trace("$progress values loaded.") if T(3) && ($progress % 1000 == 0);
+         }
+     }
+     # Return the result.
+     return $retVal;
+ }
+ =head3 BackupKeys
+ C<< my $stats = $attrDB->BackupKeys($fileName, %options); >>
+ Backup the attribute key information from the attribute database.
+ =over 4
+ =item fileName
+ Name of the output file.
+ =item options
+ Options for modifying the backup process.
+ =item RETURN
+ Returns a statistics object for the backup.
+ =back
+ Currently there are no options. The backup is straight to a text file in
+ tab-delimited format. Each key is backup up to two lines. The first line
+ is all of the data from the B<AttributeKey> table. The second is a
+ tab-delimited list of all the groups.
+ =cut
+ sub BackupKeys {
+     # Get the parameters.
+     my ($self, $fileName, %options) = @_;
+     # Declare the return variable.
+     my $retVal = Stats->new();
+     # Open the output file.
+     my $fh = Open(undef, ">$fileName");
+     # Set up to read the keys.
+     my $keyQuery = $self->Get(['AttributeKey'], "", []);
+     # Loop through the keys.
+     while (my $keyData = $keyQuery->Fetch()) {
+         $retVal->Add(key => 1);
+         # Get the fields.
+         my ($id, $type, $description) = $keyData->Values(['AttributeKey(id)', 'AttributeKey(data-type)',
+                                                           'AttributeKey(description)']);
+         # Escape any tabs or new-lines in the description.
+         my $escapedDescription = Tracer::Escape($description);
+         # Write the key data to the output.
+         Tracer::PutLine($fh, [$id, $type, $escapedDescription]);
+         # Get the key's groups.
+         my @groups = $self->GetFlat(['IsInGroup'], "IsInGroup(from-link) = ?", [$id],
+                                     'IsInGroup(to-link)');
+         $retVal->Add(memberships => scalar(@groups));
+         # Write them to the output. Note we put a marker at the beginning to insure the line
+         # is nonempty.
+         Tracer::PutLine($fh, ['#GROUPS', @groups]);
+     }
+     # Return the result.
+     return $retVal;
+ }
+ =head3 RestoreKeys
+ C<< my $stats = $attrDB->RestoreKeys($fileName, %options); >>
+ Restore the attribute keys and groups from a backup file.
+ =over 4
+ =item fileName
+ Name of the file containing the backed-up keys. Each key has a pair of lines,
+ one containing the key data and one listing its groups.
+ =back
+ =cut
+ sub RestoreKeys {
+     # Get the parameters.
+     my ($self, $fileName, %options) = @_;
+     # Declare the return variable.
+     my $retVal = Stats->new();
+     # Set up a hash to hold the group IDs.
+     my %groups = ();
+     # Open the file.
+     my $fh = Open(undef, "<$fileName");
+     # Loop until we're done.
+     while (! eof $fh) {
+         # Get a key record.
+         my ($id, $dataType, $description) = Tracer::GetLine($fh);
+         if ($id eq '#GROUPS') {
+             Confess("Group record found when key record expected.");
+         } elsif (! defined($description)) {
+             Confess("Invalid format found for key record.");
+         } else {
+             $retVal->Add("keyIn" => 1);
+             # Add this key to the database.
+             $self->InsertObject('AttributeKey', { id => $id, 'data-type' => $dataType,
+                                                   description => Tracer::UnEscape($description) });
+             Trace("Attribute $id stored.") if T(3);
+             # Get the group line.
+             my ($marker, @groups) = Tracer::GetLine($fh);
+             if (! defined($marker)) {
+                 Confess("End of file found where group record expected.");
+             } elsif ($marker ne '#GROUPS') {
+                 Confess("Group record not found after key record.");
+             } else {
+                 $retVal->Add(memberships => scalar(@groups));
+                 # Connect the groups.
+                 for my $group (@groups) {
+                     # Find out if this is a new group.
+                     if (! $groups{$group}) {
+                         $retVal->Add(newGroup => 1);
+                         # Add the group.
+                         $self->InsertObject('AttributeGroup', { id => $group });
+                         Trace("Group $group created.") if T(3);
+                         # Make sure we know it's not new.
+                         $groups{$group} = 1;
+                     }
+                     # Connect the group to our key.
+                     $self->InsertObject('IsInGroup', { 'from-link' => $id, 'to-link' => $group });
+                 }
+                 Trace("$id added to " . scalar(@groups) . " groups.") if T(3);
+             }
+         }
+     }
+     # Return the result.
+     return $retVal;
+ }
+ =head3 BackupAllAttributes
+ C<< my $stats = $attrDB->BackupAllAttributes($fileName, %options); >>
+ Backup all of the attributes to a file. The attributes will be stored in a
+ tab-delimited file suitable for reloading via L</LoadAttributesFrom>.
+ =over 4
+ =item fileName
+ Name of the file to which the attribute data should be backed up.
+ =item options
+ Hash of options for the backup.
+ =item RETURN
+ Returns a statistics object describing the backup.
+ =back
+ Currently there are no options defined.
+ =cut
+ sub BackupAllAttributes {
+     # Get the parameters.
+     my ($self, $fileName, %options) = @_;
+     # Declare the return variable.
+     my $retVal = Stats->new();
+     # Get a list of the keys.
+     my @keys = $self->GetFlat(['AttributeKey'], "", [], 'AttributeKey(id)');
+     Trace(scalar(@keys) . " keys found during backup.") if T(2);
+     # Open the file for output.
+     my $fh = Open(undef, ">$fileName");
+     # Loop through the keys.
+     for my $key (@keys) {
+         Trace("Backing up attribute $key.") if T(3);
+         $retVal->Add(keys => 1);
+         # Loop through this key's values.
+         my $query = $self->Get(['HasValueFor'], "HasValueFor(from-link) = ?", [$key]);
+         my $valuesFound = 0;
+         while (my $line = $query->Fetch()) {
+             $valuesFound++;
+             # Get this row's data.
+             my @row = $line->Values(['HasValueFor(to-link)', 'HasValueFor(from-link)',
+                                      'HasValueFor(value)']);
+             # Write it to the file.
+             Tracer::PutLine($fh, \@row);
+         }
+         Trace("$valuesFound values backed up for key $key.") if T(3);
+         $retVal->Add(values => $valuesFound);
+     }
+     # Return the result.
+     return $retVal;
+ }
  =head3 FieldMenu
- C<< my $menuHtml = $attrDB->FieldMenu($cgi, $height, $name, $newFlag, $noteControl, $typeControl); >>
+ C<< my $menuHtml = $attrDB->FieldMenu($cgi, $height, $name, $keys, %options); >>
  Return the HTML for a menu to select an attribute field. The menu will
  be a standard SELECT/OPTION thing which is called "popup menu" in the
  CGI package, but actually looks like a list. The list will contain
- one selectable row per field, grouped by entity.
+ one selectable row per field.
  =over 4
-Line 556
+Line 739
  Name to give to the menu. This is the name under which the value will
  appear when the form is submitted.
- =item newFlag (optional)
+ =item keys
+ Reference to a hash mapping each attribute key name to a list reference,
+ the list itself consisting of the attribute data type, its description,
+ and a list of its groups.
+ =item options
+ Hash containing options that modify the generation of the menu.
+ =item RETURN
+ Returns the HTML to create a form field that can be used to select an
+ attribute from the custom attributes system.
+ =back
+ The permissible options are as follows.
+ =over 4
+ =item new
  If TRUE, then extra rows will be provided to allow the user to select
  a new attribute. In other words, the user can select an existing
  attribute, or can choose a C<(new)> marker to indicate a field to
  be created in the parent entity.
- =item noteControl (optional)
+ =item notes
  If specified, the name of a variable for displaying the notes attached
  to the field. This must be in Javascript form ready for assignment.
-Line 574
+Line 778
  it is copied in. Specifying this parameter generates Javascript for
  displaying the field description when a field is selected.
- =item typeControl (optional)
+ =item type
  If specified, the name of a variable for displaying the field's
  data type. Data types are a much more controlled vocabulary than
-Line 582
+Line 786
  raw value is put into the specified variable. Otherwise, the same
  rules apply to this value that apply to I<$noteControl>.
- =item RETURN
+ =item groups
- Returns the HTML to create a form field that can be used to select an
+ If specified, the name of a multiple-selection list control (also called
- attribute from the custom attributes system.
+ a popup menu) which shall be used to display the selected groups.
  =back
-Line 593
+Line 797
  sub FieldMenu {
      # Get the parameters.
-     my ($self, $cgi, $height, $name, $newFlag, $noteControl, $typeControl) = @_;
+     my ($self, $cgi, $height, $name, $keys, %options) = @_;
-     # These next two hashes make everything happen. "entities"
+     # Reformat the list of keys.
-     # maps each entity name to the list of values to be put into its
+     my %keys = %{$keys};
-     # option group. "labels" maps each entity name to a map from values
+     # Add the (new) key, if needed.
-     # to labels.
+     if ($options{new}) {
-     my @entityNames = sort ($self->GetEntityTypes());
+         $keys{NewName()} = ["string", ""];
-     my %entities = map { $_ => [] } @entityNames;
+     }
-     my %labels = map { $_ => { }} @entityNames;
+     # Get a sorted list of key.
-     # Loop through the entities, adding the existing attributes.
+     my @keys = sort keys %keys;
-     for my $entity (@entityNames) {
+     # We need to create the name for the onChange function. This function
-         # Get this entity's field table.
-         my $fieldHash = $self->GetFieldTable($entity);
-         # Get its field list in our local hashes.
-         my $fieldList = $entities{$entity};
-         my $labelList = $labels{$entity};
-         # Add the NEW fields if we want them.
-         if ($newFlag) {
-             push @{$fieldList}, $entity;
-             $labelList->{$entity} = "(new)";
-         }
-         # Loop through the fields in the hash. We only keep the ones with a
-         # secondary relation name. (In other words, the name of the relation
-         # in which the field appears cannot be the same as the entity name.)
-         for my $fieldName (sort keys %{$fieldHash}) {
-             if ($fieldHash->{$fieldName}->{relation} ne $entity) {
-                 my $value = "$entity/$fieldName";
-                 push @{$fieldList}, $value;
-                 $labelList->{$value} = $fieldName;
-             }
-         }
-     }
-     # Now we have a hash and a list for each entity, and they correspond
-     # exactly to what the $cgi->optgroup function expects.
-     # The last step is to create the name for the onChange function. This function
      # may not do anything, but we need to know the name to generate the HTML
      # for the menu.
      my $changeName = "${name}_setNotes";
      my $retVal = $cgi->popup_menu({name => $name,
                                     size => $height,
                                     onChange => "$changeName(this.value)",
-                                    values => [map { $cgi->optgroup(-name => $_,
+                                    values => \@keys,
-                                                                    -values => $entities{$_},
+                                   });
-                                                                    -labels => $labels{$_})
-                                                   } @entityNames]}
-                                  );
      # Create the change function.
      $retVal .= "\n<script language=\"javascript\">\n";
      $retVal .= "    function $changeName(fieldValue) {\n";
-     # The function only has a body if we have a notes control to store the description.
+     # The function only has a body if we have a control to store data about the
-     if ($noteControl || $typeControl) {
+     # attribute.
+     if ($options{notes} || $options{type} || $options{groups}) {
          # Check to see if we're storing HTML or text into the note control.
+         my $noteControl = $options{notes};
          my $htmlMode = ($noteControl && $noteControl =~ /innerHTML$/);
          # We use a CASE statement based on the newly-selected field value. The
          # field description will be stored in the JavaScript variable "myText"
-Line 652
+Line 831
          $retVal .= "        var myText = \"\";\n";
          $retVal .= "        var myType = \"string\";\n";
          $retVal .= "        switch (fieldValue) {\n";
-         # Loop through the entities.
+         # Loop through the keys.
-         for my $entity (@entityNames) {
+         for my $key (@keys) {
-             # Get the entity's field hash. This has the notes in it.
-             my $fieldHash = $self->GetFieldTable($entity);
-             # Loop through the values we might see for this entity's fields.
-             my $fields = $entities{$entity};
-             for my $value (@{$fields}) {
-                 # Only proceed if we have an existing field.
-                 if ($value =~ m!/(.+)$!) {
-                     # Get the field's hash element.
-                     my $element = $fieldHash->{$1};
                      # Generate this case.
-                     $retVal .= "        case \"$value\" :\n";
+             $retVal .= "        case \"$key\" :\n";
                      # Here we either want to update the note display, the
-                     # type display, or both.
+             # type display, the group list, or a combination of them.
+             my ($type, $notes, @groups) = @{$keys{$key}};
                      if ($noteControl) {
-                         # Here we want the notes updated.
-                         my $notes = $element->{Notes}->{content};
                          # Insure it's in the proper form.
                          if ($htmlMode) {
                              $notes = ERDB::HTMLNote($notes);
-Line 679
+Line 848
                          $notes =~ s/"/\\"/g;
                          $retVal .= "           myText = \"$notes\";\n";
                      }
-                     if ($typeControl) {
+             if ($options{type}) {
                          # Here we want the type updated.
-                         my $type = $element->{type};
                          $retVal .= "           myType = \"$type\";\n";
                      }
+             if ($options{groups}) {
+                 # Here we want the groups shown. Get a list of this attribute's groups.
+                 # We'll search through this list for each group to see if it belongs with
+                 # our attribute.
+                 my $groupLiteral = "=" . join("=", @groups) . "=";
+                 # Now we need some variables containing useful code for the javascript. It's
+                 # worth knowing we go through a bit of pain to insure $groupField[i] isn't
+                 # parsed as an array element.
+                 my $groupField = $options{groups};
+                 my $currentField = $groupField . "[i]";
+                 # Do the javascript.
+                 $retVal .= "           var groupList = \"$groupLiteral\";\n";
+                 $retVal .= "           for (var i = 0; i < $groupField.length; i++) {\n";
+                 $retVal .= "              var srchString = \"=\" + $currentField.value + \"=\";\n";
+                 $retVal .= "              var srchLoc = groupList.indexOf(srchString);\n";
+                 $retVal .= "              $currentField.checked = (srchLoc >= 0);\n";
+                 $retVal .= "           }\n";
+             }
                      # Close this case.
                      $retVal .= "           break;\n";
                  }
-             }
-         }
          # Close the CASE statement and make the appropriate assignments.
          $retVal .= "        }\n";
          if ($noteControl) {
              $retVal .= "        $noteControl = myText;\n";
          }
-         if ($typeControl) {
+         if ($options{type}) {
-             $retVal .= "        $typeControl = myType;\n";
+             $retVal .= "        $options{type} = myType;\n";
          }
      }
      # Terminate the change function.
-Line 705
+Line 889
      return $retVal;
  }
- =head3 MatchSqlPattern
+ =head3 GetGroups
+ C<< my @groups = $attrDB->GetGroups(); >>
+ Return a list of the available groups.
+ =cut
+ sub GetGroups {
+     # Get the parameters.
+     my ($self) = @_;
+     # Get the groups.
+     my @retVal = $self->GetFlat(['AttributeGroup'], "", [], 'AttributeGroup(id)');
+     # Return them.
+     return @retVal;
+ }
+ =head3 GetAttributeData
- C<< my $matched = CustomAttributes::MatchSqlPattern($value, $pattern); >>
+ C<< my %keys = $attrDB->GetAttributeData($type, @list); >>
- Determine whether or not a specified value matches an SQL pattern. An SQL
+ Return attribute data for the selected attributes. The attribute
- pattern has two wild card characters: C<%> that matches multiple characters,
+ data is a hash mapping each attribute key name to a n-tuple containing the
- and C<_> that matches a single character. These can be escaped using a
+ data type, the description, and the groups. This is the same format expected in
- backslash (C<\>). We pull this off by converting the SQL pattern to a
+ the L</FieldMenu> and L</ControlForm> methods for the list of attributes to display.
- PERL regular expression. As per SQL rules, the match is case-insensitive.
  =over 4
- =item value
+ =item type
- Value to be matched against the pattern. Note that an undefined or empty
+ Type of attribute criterion: C<name> for attributes whose names begin with the
- value will not match anything.
+ specified string, or C<group> for attributes in the specified group.
- =item pattern
+ =item list
- SQL pattern against which to match the value. An undefined or empty pattern will
+ List containing the names of the groups or keys for the desired attributes.
- match everything.
  =item RETURN
- Returns TRUE if the value and pattern match, else FALSE.
+ Returns a hash mapping each attribute key name to its data type, description, and
+ parent groups.
  =back
  =cut
- sub MatchSqlPattern {
+ sub GetAttributeData {
      # Get the parameters.
-     my ($value, $pattern) = @_;
+     my ($self, $type, @list) = @_;
-     # Declare the return variable.
+     # Set up a hash to store the attribute data.
-     my $retVal;
+     my %retVal = ();
-     # Insure we have a pattern.
+     # Loop through the list items.
-     if (! defined($pattern) || $pattern eq "") {
+     for my $item (@list) {
-         $retVal = 1;
+         # Set up a query for the desired attributes.
-     } else {
+         my $query;
-         # Break the pattern into pieces around the wildcard characters. Because we
+         if ($type eq 'name') {
-         # use parentheses in the split function's delimiter expression, we'll get
+             # Here we're doing a generic name search. We need to escape it and then tack
-         # list elements for the delimiters as well as the rest of the string.
+             # on a %.
-         my @pieces = split /([_%]|\\[_%])/, $pattern;
+             my $parm = $item;
-         # Check some fast special cases.
+             $parm =~ s/_/\\_/g;
-         if ($pattern eq '%') {
+             $parm =~ s/%/\\%/g;
-             # A null pattern matches everything.
+             $parm .= "%";
-             $retVal = 1;
+             # Ask for matching attributes. (Note that if the user passed in a null string
-         } elsif (@pieces == 1) {
+             # he'll get everything.)
-             # No wildcards, so we have a literal comparison. Note we're case-insensitive.
+             $query = $self->Get(['AttributeKey'], "AttributeKey(id) LIKE ?", [$parm]);
-             $retVal = (lc($value) eq lc($pattern));
+         } elsif ($type eq 'group') {
-         } elsif (@pieces == 2 && $pieces[1] eq '%') {
+             $query = $self->Get(['IsInGroup', 'AttributeKey'], "IsInGroup(to-link) = ?", [$item]);
-             # A wildcard at the end, so we have a substring match. This is also case-insensitive.
-             $retVal = (lc(substr($value, 0, length($pieces[0]))) eq lc($pieces[0]));
          } else {
-             # Okay, we have to do it the hard way. Convert each piece to a PERL pattern.
+             Confess("Unknown attribute query type \"$type\".");
-             my $realPattern = "";
-             for my $piece (@pieces) {
-                 # Determine the type of piece.
-                 if ($piece eq "") {
-                     # Empty pieces are ignored.
-                 } elsif ($piece eq "%") {
-                     # Here we have a multi-character wildcard. Note that it can match
-                     # zero or more characters.
-                     $realPattern .= ".*"
-                 } elsif ($piece eq "_") {
-                     # Here we have a single-character wildcard.
-                     $realPattern .= ".";
-                 } elsif ($piece eq "\\%" || $piece eq "\\_") {
-                     # This is an escape sequence (which is a rare thing, actually).
-                     $realPattern .= substr($piece, 1, 1);
-                 } else {
-                     # Here we have raw text.
-                     $realPattern .= quotemeta($piece);
                  }
+         while (my $row = $query->Fetch()) {
+             # Get this attribute's data.
+             my ($key, $type, $notes) = $row->Values(['AttributeKey(id)', 'AttributeKey(data-type)',
+                                                      'AttributeKey(description)']);
+             # If it's new, get its groups and add it to the return hash.
+             if (! exists $retVal{$key}) {
+                 my @groups = $self->GetFlat(['IsInGroup'], "IsInGroup(from-link) = ?",
+                                             [$key], 'IsInGroup(to-link)');
+                 $retVal{$key} = [$type, $notes, @groups];
              }
-             # Do the match.
-             $retVal = ($value =~ /^$realPattern$/i ? 1 : 0);
          }
      }
      # Return the result.
-     return $retVal;
+     return %retVal;
  }
- =head3 MigrateAttributes
+ =head2 Internal Utility Methods
+ =head3 _KeywordString
- C<< CustomAttributes::MigrateAttributes($fig); >>
+ C<< my $keywordString = $ca->_KeywordString($key, $value); >>
- Migrate all the attributes data from the specified FIG instance. This is a long, slow
+ Compute the keyword string for a specified key/value pair. This consists of the
- method used to convert the old attribute data to the new system. Only attribute
+ key name and value converted to lower case with underscores translated to spaces.
- keys that are not already in the database will be loaded, and only for entity instances
- current in the database. To get an accurate capture of the attributes in the given
+ This method is for internal use only. It is called whenever we need to update or
- instance, you may want to clear the database and the DBD before starting and
+ insert a B<HasValueFor> record.
- run L</Refresh> to populate the entities.
  =over 4
- =item fig
+ =item key
+ Name of the relevant attribute key.
+ =item target
+ ID of the target object to which this key/value pair will be associated.
+ =item value
+ The value to store for this key/object combination.
+ =item RETURN
- A FIG object that can be used to retrieve attributes for migration purposes.
+ Returns the value that should be stored as the keyword string for the specified
+ key/value pair.
  =back
  =cut
- sub MigrateAttributes {
+ sub _KeywordString {
      # Get the parameters.
-     my ($fig) = @_;
+     my ($self, $key, $value) = @_;
-     # Get a list of the objects to migrate. This requires connecting. Note we
+     # Get a copy of the key name and convert underscores to spaces.
-     # will map each entity type to a file name. The file will contain a list
+     my $keywordString = $key;
-     # of the object's IDs so we can get to them when we're not connected to
+     $keywordString =~ s/_/ /g;
-     # the database.
+     # Add the value convert it all to lower case.
-     my $ca = CustomAttributes->new();
+     my $retVal = lc "$keywordString $value";
-     my %objects = map { $_ => "$FIG_Config::temp/$_.keys.tbl" } $ca->GetEntityTypes();
+     # Return the result.
-     # Set up hash of the existing attribute keys for each entity type.
+     return $retVal;
-     my %oldKeys = ();
-     # Finally, we have a hash that counts the IDs for each entity type.
-     my %idCounts = map { $_ => 0 } keys %objects;
-     # Loop through the list, creating key files to read back in.
-     for my $entityType (keys %objects) {
-         Trace("Retrieving keys for $entityType.") if T(2);
-         # Create the key file.
-         my $idFile = Open(undef, ">$objects{$entityType}");
-         # Loop through the keys.
-         my @ids = $ca->GetFlat([$entityType], "", [], "$entityType(id)");
-         for my $id (@ids) {
-             print $idFile "$id\n";
-         }
-         close $idFile;
-         # In addition to the key file, we must get a list of attributes already
-         # in the database. This avoids a circularity problem that might occur if the $fig
-         # object is retrieving from the custom attributes database already.
-         my %fields = $ca->GetSecondaryFields($entityType);
-         $oldKeys{$entityType} = \%fields;
-         # Finally, we have the ID count.
-         $idCounts{$entityType} = scalar @ids;
-     }
-     # Release the custom attributes database so we can add attributes.
-     undef $ca;
-     # Loop through the objects.
-     for my $entityType (keys %objects) {
-         # Get a hash of all the attributes already in this database. These are
-         # left untouched.
-         my $myOldKeys = $oldKeys{$entityType};
-         # Create a hash to control the load file names for each attribute key we find.
-         my %keyHash = ();
-         # Set up some counters so we can trace our progress.
-         my ($totalIDs, $processedIDs, $keyCount, $valueCount) = ($idCounts{$entityType}, 0, 0, 0);
-         # Open this object's ID file.
-         Trace("Migrating data for $entityType. $totalIDs found.") if T(3);
-         my $keysIn = Open(undef, "<$objects{$entityType}");
-         while (my $id = <$keysIn>) {
-             # Remove the EOL characters.
-             chomp $id;
-             # Get this object's attributes.
-             my @allData = $fig->get_attributes($id);
-             Trace(scalar(@allData) . " attribute values found for $entityType($id).") if T(4);
-             # Loop through the attribute values one at a time.
-             for my $dataTuple (@allData) {
-                 # Get the key, value, and URL. We ignore the first element because that's the
-                 # object ID, and we already know the object ID.
-                 my (undef, $key, $value, $url) = @{$dataTuple};
-                 # Remove the buggy "1" for $url.
-                 if ($url eq "1") {
-                     $url = undef;
-                 }
-                 # Only proceed if this is not an old key.
-                 if (! $myOldKeys->{$key}) {
-                     # See if we've run into this key before.
-                     if (! exists $keyHash{$key}) {
-                         # Here we need to create the attribute key in the database.
-                         StoreAttributeKey($entityType, $key, 'text',
-                                           "Key migrated automatically from the FIG system. " .
-                                           "Please replace these notes as soon as possible " .
-                                           "with useful text."
-                                          );
-                         # Compute the attribute's load file name and open it for output.
-                         my $fileName = "$FIG_Config::temp/$entityType.$key.load.tbl";
-                         my $fh = Open(undef, ">$fileName");
-                         # Store the file name and handle.
-                         $keyHash{$key} = {h => $fh, name => $fileName};
-                         # Count this key.
-                         $keyCount++;
-                     }
-                     # Smash the value and the URL together.
-                     if (defined($url) && length($url) > 0) {
-                         $value .= "::$url";
-                     }
-                     # Write the attribute value to the load file.
-                     Tracer::PutLine($keyHash{$key}->{h}, [$id, $value]);
-                     $valueCount++;
-                 }
-             }
-             # Now we've finished all the attributes for this object. Count and trace it.
-             $processedIDs++;
-             if ($processedIDs % 500 == 0) {
-                 Trace("$processedIDs of $totalIDs ${entityType}s processed.") if T(3);
-                 Trace("$entityType has $keyCount keys and $valueCount values so far.") if T(3);
-             }
-         }
-         # Now we've finished all the attributes for all objects of this type.
-         Trace("$processedIDs ${entityType}s processed, with $keyCount keys and $valueCount values.") if T(2);
-         # Loop through the files, loading the keys into the database.
-         Trace("Connecting to database.") if T(2);
-         my $objectCA = CustomAttributes->new();
-         Trace("Loading key files.") if T(2);
-         for my $key (sort keys %keyHash) {
-             # Close the key's load file.
-             close $keyHash{$key}->{h};
-             # Reopen it for input.
-             my $fileName = $keyHash{$key}->{name};
-             my $fh = Open(undef, "<$fileName");
-             Trace("Loading $key from $fileName.") if T(3);
-             my $stats = $objectCA->LoadAttributeKey($entityType, $key, $fh, 0, 1);
-             Trace("Statistics for $key of $entityType:\n" . $stats->Show()) if T(3);
-         }
-         # All the keys for this entity type are now loaded.
-         Trace("Key files loaded for $entityType.") if T(2);
-     }
-     # All keys for all entity types are now loaded.
-     Trace("Migration complete.") if T(2);
  }
- =head3 ComputeObjectTypeFromID
+ =head3 _QueryResults
- C<< my ($entityName, $id) = CustomAttributes::ComputeObjectTypeFromID($objectID); >>
+ C<< my @attributeList = $attrDB->_QueryResults($query, @values); >>
- This method will compute the entity type corresponding to a specified object ID.
+ Match the results of a B<HasValueFor> query against value criteria and return
- If the object ID begins with C<fig|>, it is presumed to be a feature ID. If it
+ the results. This is an internal method that splits the values coming back
- is all digits with a single period, it is presumed to by a genome ID. Otherwise,
+ and matches the sections against the specified section patterns. It serves
- it must be a list reference. In this last case the first list element will be
+ as the back end to L</GetAttributes> and L</FindAttributes>.
- taken as the entity type and the second will be taken as the actual ID.
  =over 4
- =item objectID
+ =item query
- Object ID to examine.
+ A query object that will return the desired B<HasValueFor> records.
+ =item values
+ List of the desired attribute values, section by section. If C<undef>
+ or an empty string is specified, all values in that section will match. A
+ generic match can be requested by placing a percent sign (C<%>) at the end.
+ In that case, all values that match up to and not including the percent sign
+ will match. You may also specify a regular expression enclosed
+ in slashes. All values that match the regular expression will be returned. For
+ performance reasons, only values have this extra capability.
  =item RETURN
- Returns a 2-element list consisting of the entity type followed by the specified ID.
+ Returns a list of tuples. The first element in the tuple is an object ID, the
+ second is an attribute key, and the remaining elements are the sections of
+ the attribute value. All of the tuples will match the criteria set forth in
+ the parameter list.
  =back
  =cut
- sub ComputeObjectTypeFromID {
+ sub _QueryResults {
      # Get the parameters.
-     my ($objectID) = @_;
+     my ($self, $query, @values) = @_;
-     # Declare the return variables.
+     # Declare the return value.
-     my ($entityName, $id);
+     my @retVal = ();
-     # Only proceed if the object ID is defined. If it's not, we'll be returning a
+     # Get the number of value sections we have to match.
-     # pair of undefs.
+     my $sectionCount = scalar(@values);
-     if ($objectID) {
+     # Loop through the assignments found.
-         if (ref $objectID eq 'ARRAY') {
+     while (my $row = $query->Fetch()) {
-             # Here we have the new-style list reference. Pull out its pieces.
+         # Get the current row's data.
-             ($entityName, $id) = @{$objectID};
+         my ($id, $key, $valueString) = $row->Values(['HasValueFor(to-link)', 'HasValueFor(from-link)',
-         } else {
+                                                       'HasValueFor(value)']);
-             # Here the ID is the outgoing ID, and we need to look at its structure
+         # Break the value into sections.
-             # to determine the entity type.
+         my @sections = split($self->{splitter}, $valueString);
-             $id = $objectID;
+         # Match each section against the incoming values. We'll assume we're
-             if ($objectID =~ /^\d+\.\d+/) {
+         # okay unless we learn otherwise.
-                 # Digits with a single period is a genome.
+         my $matching = 1;
-                 $entityName = 'Genome';
+         for (my $i = 0; $i < $sectionCount && $matching; $i++) {
-             } elsif ($objectID =~ /^fig\|/) {
+             # We need to check to see if this section is generic.
-                 # The "fig|" prefix indicates a feature.
+             my $value = $values[$i];
-                 $entityName = 'Feature';
+             Trace("Current value pattern is \"$value\".") if T(4);
+             if (substr($value, -1, 1) eq '%') {
+                 Trace("Generic match used.") if T(4);
+                 # Here we have a generic match.
+                 my $matchLen = length($values[$i] - 1);
+                 $matching = substr($sections[$i], 0, $matchLen) eq
+                             substr($values[$i], 0, $matchLen);
+             } elsif ($value =~ m#^/(.+)/[a-z]*$#) {
+                 Trace("Regular expression detected.") if T(4);
+                 # Here we have a regular expression match.
+                 my $section = $sections[$i];
+                 $matching = eval("\$section =~ $value");
              } else {
-                 # Anything else is illegal!
+                 # Here we have a strict match.
-                 Confess("Invalid attribute ID specification \"$objectID\".");
+                 Trace("Strict match used.") if T(4);
+                 $matching = ($sections[$i] eq $values[$i]);
              }
          }
+         # If we match, output this row to the return list.
+         if ($matching) {
+             push @retVal, [$id, $key, @sections];
      }
-     # Return the result.
+     }
-     return ($entityName, $id);
+     # Return the rows found.
+     return @retVal;
  }
  =head2 FIG Method Replacements
  The following methods are used by B<FIG.pm> to replace the previous attribute functionality.
- Some of the old functionality is no longer present. Controlled vocabulary is no longer
+ Some of the old functionality is no longer present: controlled vocabulary is no longer
  supported and there is no longer any searching by URL. Fortunately, neither of these
  capabilities were used in the old system.
-Line 999
+Line 1122
  value of the splitter parameter on the constructor (L</new>). The default is double
  colons C<::>.
- So, for example, an old-style keyword with a /value of C<essential> and a URL of
+ So, for example, an old-style keyword with a value of C<essential> and a URL of
  C<http://www.sciencemag.org/cgi/content/abstract/293/5538/2266> using the default
  splitter value would be stored as
-Line 1010
+Line 1133
  =head3 GetAttributes
- C<< my @attributeList = $attrDB->GetAttributes($objectID, $key, @valuePatterns); >>
+ C<< my @attributeList = $attrDB->GetAttributes($objectID, $key, @values); >>
  In the database, attribute values are sectioned into pieces using a splitter
  value specified in the constructor (L</new>). This is not a requirement of
  the attribute system as a whole, merely a convenience for the purpose of
- these methods. If you are using the static method calls instead of the
+ these methods. If a value has multiple sections, each section
- object-based calls, the splitter will always be the default value of
+ is matched against the corresponding criterion in the I<@valuePatterns> list.
- double colons (C<::>). If a value has multiple sections, each section
- is matched against the correspond criterion in the I<@valuePatterns> list.
  This method returns a series of tuples that match the specified criteria. Each tuple
  will contain an object ID, a key, and one or more values. The parameters to this
- method therefore correspond structurally to the values expected in each tuple.
+ method therefore correspond structurally to the values expected in each tuple. In
+ addition, you can ask for a generic search by suffixing a percent sign (C<%>) to any
+ of the parameters. So, for example,
-     my @attributeList = GetAttributes('fig|100226.1.peg.1004', 'structure%', 1, 2);
+     my @attributeList = $attrDB->GetAttributes('fig|100226.1.peg.1004', 'structure%', 1, 2);
  would return something like
-Line 1033
+Line 1156
      ['fig}100226.1.peg.1004', 'structure2', 1, 2]
      ['fig}100226.1.peg.1004', 'structureA', 1, 2]
- Use of C<undef> in any position acts as a wild card (all values). In addition,
+ Use of C<undef> in any position acts as a wild card (all values). You can also specify
- the I<$key> and I<@valuePatterns> parameters can contain SQL pattern characters: C<%>, which
+ a list reference in the ID column. Thus,
- matches any sequence of characters, and C<_>, which matches any single character.
- (You can use an escape sequence C<\%> or C<\_> to match an actual percent sign or
+     my @attributeList = $attrDB->GetAttributes(['100226.1', 'fig|100226.1.%'], 'PUBMED');
- underscore.)
+ would get the PUBMED attribute data for Streptomyces coelicolor A3(2) and all its
+ features.
  In addition to values in multiple sections, a single attribute key can have multiple
  values, so even
-     my @attributeList = GetAttributes($peg, 'virulent');
+     my @attributeList = $attrDB->GetAttributes($peg, 'virulent');
  which has no wildcard in the key or the object ID, may return multiple tuples.
- For reasons of backward compatability, we examine the structure of the object ID to
+ Value matching in this system works very poorly, because of the way multiple values are
- determine the entity type. In that case the only two types allowed are C<Genome> and
+ stored. For the object ID and key name, we create queries that filter for the desired
- C<Feature>. An alternative method is to use a list reference, with the list consisting
+ results. For the values, we do a comparison after the attributes are retrieved from the
- of an entity type name and the actual ID. Thus, the above example could equivalently
+ database. As a result, queries in which filter only on value end up reading the entire
- be written as
+ attribute table to find the desired results.
-     my @attributeList = GetAttributes([Feature => $peg], 'virulent');
- The list-reference approach allows us to add attributes to other entity types in
- the future. Doing so, however, will require modifying the L</Refresh> method and
- updated the database design XML.
- The list-reference approach also allows for a more fault-tolerant approach to
- getting all objects with a particular attribute.
-     my @attributeList = GetAttributes([Feature => undef], 'virulent');
- will only return feature attributes, while
-     my @attributeList = GetAttributes(undef, 'virulent');
- could at some point in the future get you attributes for genomes or even subsystems
- as well as features.
  =over 4
  =item objectID
- ID of the genome or feature whose attributes are desired. In general, an ID that
+ ID of object whose attributes are desired. If the attributes are desired for multiple
- starts with C<fig|> is treated as a feature ID, and an ID that is all digits with a
+ objects, this parameter can be specified as a list reference. If the attributes are
- single period is treated as a genome ID. For other entity types, use a list reference; in
+ desired for all objects, specify C<undef> or an empty string. Finally, you can specify
- this case the first list element is the entity type and the second is the ID. A value of
+ attributes for a range of object IDs by putting a percent sign (C<%>) at the end.
- C<undef> or an empty string here will match all objects.
  =item key
- Attribute key name. Since attributes are stored as fields in the database with a
+ Attribute key name. A value of C<undef> or an empty string will match all
- field name equal to the key name, it is very fast to find a list of all the
+ attribute keys. If the values are desired for multiple keys, this parameter can be
- matching keys. Each key's values require a separate query, however, which may
+ specified as a list reference. Finally, you can specify attributes for a range of
- be a performance problem if the pattern matches a lot of keys. Wild cards are
+ keys by putting a percent sign (C<%>) at the end.
- acceptable here, and a value of C<undef> or an empty string will match all
- attribute keys.
- =item valuePatterns
+ =item values
  List of the desired attribute values, section by section. If C<undef>
- or an empty string is specified, all values in that section will match.
+ or an empty string is specified, all values in that section will match. A
+ generic match can be requested by placing a percent sign (C<%>) at the end.
+ In that case, all values that match up to and not including the percent sign
+ will match. You may also specify a regular expression enclosed
+ in slashes. All values that match the regular expression will be returned. For
+ performance reasons, only values have this extra capability.
  =item RETURN
-Line 1107
+Line 1216
  sub GetAttributes {
      # Get the parameters.
-     my ($self, $objectID, $key, @valuePatterns) = @_;
+     my ($self, $objectID, $key, @values) = @_;
-     # Declare the return variable.
+     # We will create one big honking query. The following hash will build the filter
-     my @retVal = ();
+     # clause and a parameter list.
-     # Determine the entity types for our search.
+     my %data = ('HasValueFor(from-link)' => $key, 'HasValueFor(to-link)' => $objectID);
-     my @objects = ();
+     my @filter = ();
-     my ($actualObjectID, $computedType);
+     my @parms = ();
-     if (! $objectID) {
+     # This next loop goes through the different fields that can be specified in the
-         push @objects, $self->GetEntityTypes();
+     # parameter list and generates filters for each.
+     for my $field (keys %data) {
+         # Accumulate filter information for this field. We will OR together all the
+         # elements accumulated to create the final result.
+         my @fieldFilter = ();
+         # Get the specified data from the caller.
+         my $fieldPattern = $data{$field};
+         # Only proceed if the pattern is one that won't match everything.
+         if (defined($fieldPattern) && $fieldPattern ne "" && $fieldPattern ne "%") {
+             # Convert the pattern to an array.
+             my @patterns = ();
+             if (ref $fieldPattern eq 'ARRAY') {
+                 push @patterns, @{$fieldPattern};
      } else {
-         ($computedType, $actualObjectID) = ComputeObjectTypeFromID($objectID);
+                 push @patterns, $fieldPattern;
-         push @objects, $computedType;
      }
-     # Loop through the entity types.
+             # Only proceed if the array is nonempty. The loop will work fine if the
-     for my $entityType (@objects) {
+             # array is empty, but when we build the filter string at the end we'll
-         # Now we need to find all the matching keys. The keys are actually stored in
+             # get "()" in the filter list, which will result in an SQL syntax error.
-         # our database object, so this process is fast. Note that our
+             if (@patterns) {
-         # MatchSqlPattern method
+                 # Loop through the individual patterns.
-         my %secondaries = $self->GetSecondaryFields($entityType);
+                 for my $pattern (@patterns) {
-         my @fieldList = grep { MatchSqlPattern($_, $key) } keys %secondaries;
+                     # Check for a generic request.
-         # Now we figure out whether or not we need to filter by object. We will always
+                     if (substr($pattern, -1, 1) ne '%') {
-         # filter by key to a limited extent, so if we're filtering by object we need an
+                         # Here we have a normal request.
-         # AND to join the object ID filter with the key filter.
+                         push @fieldFilter, "$field = ?";
-         my $filter = "";
+                         push @parms, $pattern;
-         my @params = ();
+                     } else {
-         if (defined($actualObjectID)) {
+                         # Here we have a generate request, so we will use the LIKE operator to
-             # Here the caller wants to filter on object ID. Check for a pattern.
+                         # filter the field to this value pattern.
-             my $comparator = ($actualObjectID =~ /%/ ? "LIKE" : "=");
+                         push @fieldFilter, "$field LIKE ?";
-             # Update the filter and the parameter list.
+                         # We must convert the pattern value to an SQL match pattern. First
-             $filter = "$entityType(id) $comparator ? AND ";
+                         # we get a copy of it.
-             push @params, $actualObjectID;
+                         my $actualPattern = $pattern;
-         }
+                         # Now we escape the underscores. Underscores are an SQL wild card
-         # It's time to begin making queries. We process one attribute key at a time, because
+                         # character, but they are used frequently in key names and object IDs.
-         # each attribute is actually a different field in the database. We know here that
+                         $actualPattern =~ s/_/\\_/g;
-         # all the keys we've collected are for the correct entity because we got them from
+                         # Add the escaped pattern to the bound parameter list.
-         # the DBD. That's a good thing, because an invalid key name will cause an SQL error.
+                         push @parms, $actualPattern;
-         for my $key (@fieldList) {
+                     }
-             # Get all of the attribute values for this key.
+                 }
-             my @dataRows = $self->GetAll([$entityType], "$filter$entityType($key) IS NOT NULL",
+                 # Form the filter for this field.
-                                          \@params, ["$entityType(id)", "$entityType($key)"]);
+                 my $fieldFilterString = join(" OR ", @fieldFilter);
-             # Process each value separately. We need to verify the values and reformat the
+                 push @filter, "($fieldFilterString)";
-             # tuples. Note that GetAll will give us one row per matching object ID,
-             # with the ID first followed by a list of the data values. This is very
-             # different from the structure we'll be returning, which has one row
-             # per value.
-             for my $dataRow (@dataRows) {
-                 # Get the object ID and the list of values.
-                 my ($rowObjectID, @dataValues) = @{$dataRow};
-                 # Loop through the values. There will be one result row per attribute value.
-                 for my $dataValue (@dataValues) {
-                     # Separate this value into sections.
-                     my @sections = split("::", $dataValue);
-                     # Loop through the value patterns, looking for a mismatch. Note that
-                     # since we're working through parallel arrays, we are using an index
-                     # loop. As soon as a match fails we stop checking. This means that
-                     # if the value pattern list is longer than the number of sections,
-                     # we will fail as soon as we run out of sections.
-                     my $match = 1;
-                     for (my $i = 0; $i <= $#valuePatterns && $match; $i++) {
-                         $match = MatchSqlPattern($sections[$i], $valuePatterns[$i]);
-                     }
-                     # If we match, we save this value in the output list.
-                     if ($match) {
-                         push @retVal, [$rowObjectID, $key, @sections];
-                     }
-                 }
-                 # Here we've processed all the attribute values for the current object ID.
              }
-             # Here we've processed all the rows returned by GetAll. In general, there will
-             # be one row per object ID.
          }
-         # Here we've processed all the matching attribute keys.
      }
-     # Here we've processed all the entity types. That means @retVal has all the matching
+     # Now @filter contains one or more filter strings and @parms contains the parameter
-     # results.
+     # values to bind to them.
+     my $actualFilter = join(" AND ", @filter);
+     # Now we're ready to make our query.
+     my $query = $self->Get(['HasValueFor'], $actualFilter, \@parms);
+     # Format the results.
+     my @retVal = $self->_QueryResults($query, @values);
+     # Return the rows found.
      return @retVal;
  }
-Line 1195
+Line 1292
  =item objectID
- ID of the genome or feature to which the attribute is to be added. In general, an ID that
+ ID of the object to which the attribute is to be added.
- starts with C<fig|> is treated as a feature ID, and an ID that is all digits and periods
- is treated as a genome ID. For IDs of other types, this parameter should be a reference
- to a 2-tuple consisting of the entity type name followed by the object ID.
  =item key
- Attribute key name. This corresponds to the name of a field in the database.
+ Attribute key name.
  =item values
-Line 1225
+Line 1319
      } elsif (! @values) {
          Confess("No values specified in AddAttribute call for key $key.");
      } else {
-         # Okay, now we have some reason to believe we can do this. Start by
+         # Okay, now we have some reason to believe we can do this. Form the values
-         # computing the object type and ID.
+         # into a scalar.
-         my ($entityName, $id) = ComputeObjectTypeFromID($objectID);
-         # Form the values into a scalar.
          my $valueString = join($self->{splitter}, @values);
-         # Insert the value.
+         # Connect the object to the key.
-         $self->InsertValue($id, "$entityName($key)", $valueString);
+         $self->InsertObject('HasValueFor', { 'from-link' => $key,
+                                              'to-link'   => $objectID,
+                                              'value'     => $valueString,
+                                        });
      }
-     # Return a one. We do this for backward compatability.
+     # Return a one, indicating success. We do this for backward compatability.
      return 1;
  }
-Line 1243
+Line 1338
  Delete the specified attribute key/value combination from the database.
- The first form will connect to the database and release it. The second form
- uses the database connection contained in the object.
  =over 4
  =item objectID
- ID of the genome or feature to which the attribute is to be added. In general, an ID that
+ ID of the object whose attribute is to be deleted.
- starts with C<fig|> is treated as a feature ID, and an ID that is all digits and periods
- is treated as a genome ID. For IDs of other types, this parameter should be a reference
- to a 2-tuple consisting of the entity type name followed by the object ID.
  =item key
- Attribute key name. This corresponds to the name of a field in the database.
+ Attribute key name.
  =item values
- One or more values to be associated with the key.
+ One or more values associated with the key. If no values are specified, then all values
+ will be deleted. Otherwise, only a matching value will be deleted.
  =back
-Line 1275
+Line 1365
          Confess("No object ID specified for DeleteAttribute call.");
      } elsif (! defined($key)) {
          Confess("No attribute key specified for DeleteAttribute call.");
-     } elsif (! @values) {
+     } elsif (scalar(@values) == 0) {
-         Confess("No values specified in DeleteAttribute call for key $key.");
+         # Here we erase the entire key for this object.
+         $self->DeleteRow('HasValueFor', $key, $objectID);
      } else {
-         # Now compute the object type and ID.
+         # Here we erase the matching values.
-         my ($entityName, $id) = ComputeObjectTypeFromID($objectID);
-         # Form the values into a scalar.
          my $valueString = join($self->{splitter}, @values);
-         # Delete the value.
+         $self->DeleteRow('HasValueFor', $key, $objectID, { value => $valueString });
-         $self->DeleteValue($entityName, $id, $key, $valueString);
      }
      # Return a one. This is for backward compatability.
      return 1;
  }
+ =head3 DeleteMatchingAttributes
+ C<< my @deleted = $attrDB->DeleteMatchingAttributes($objectID, $key, @values); >>
+ Delete all attributes that match the specified criteria. This is equivalent to
+ calling L</GetAttributes> and then invoking L</DeleteAttribute> for each
+ row found.
+ =over 4
+ =item objectID
+ ID of object whose attributes are to be deleted. If the attributes for multiple
+ objects are to be deleted, this parameter can be specified as a list reference. If
+ attributes are to be deleted for all objects, specify C<undef> or an empty string.
+ Finally, you can delete attributes for a range of object IDs by putting a percent
+ sign (C<%>) at the end.
+ =item key
+ Attribute key name. A value of C<undef> or an empty string will match all
+ attribute keys. If the values are to be deletedfor multiple keys, this parameter can be
+ specified as a list reference. Finally, you can delete attributes for a range of
+ keys by putting a percent sign (C<%>) at the end.
+ =item values
+ List of the desired attribute values, section by section. If C<undef>
+ or an empty string is specified, all values in that section will match. A
+ generic match can be requested by placing a percent sign (C<%>) at the end.
+ In that case, all values that match up to and not including the percent sign
+ will match. You may also specify a regular expression enclosed
+ in slashes. All values that match the regular expression will be deleted. For
+ performance reasons, only values have this extra capability.
+ =item RETURN
+ Returns a list of tuples for the attributes that were deleted, in the
+ same form as L</GetAttributes>.
+ =back
+ =cut
+ sub DeleteMatchingAttributes {
+     # Get the parameters.
+     my ($self, $objectID, $key, @values) = @_;
+     # Get the matching attributes.
+     my @retVal = $self->GetAttributes($objectID, $key, @values);
+     # Loop through the attributes, deleting them.
+     for my $tuple (@retVal) {
+         $self->DeleteAttribute(@{$tuple});
+     }
+     # Return the deleted attributes.
+     return @retVal;
+ }
  =head3 ChangeAttribute
  C<< $attrDB->ChangeAttribute($objectID, $key, \@oldValues, \@newValues); >>
-Line 1333
+Line 1478
      } elsif (! defined($newValues) || ref $newValues ne 'ARRAY') {
          Confess("No new values specified in ChangeAttribute call for key $key.");
      } else {
-         # Okay, now we do the change as a delete/add.
+         # We do the change as a delete/add.
          $self->DeleteAttribute($objectID, $key, @{$oldValues});
          $self->AddAttribute($objectID, $key, @{$newValues});
      }
-Line 1343
+Line 1488
  =head3 EraseAttribute
- C<< $attrDB->EraseAttribute($entityName, $key); >>
+ C<< $attrDB->EraseAttribute($key); >>
  Erase all values for the specified attribute key. This does not remove the
  key from the database; it merely removes all the values.
  =over 4
- =item entityName
- Name of the entity to which the key belongs. If undefined, all entities will be
- examined for the desired key.
  =item key
  Key to erase.
-Line 1365
+Line 1505
  sub EraseAttribute {
      # Get the parameters.
-     my ($self, $entityName, $key) = @_;
+     my ($self, $key) = @_;
-     # Determine the relevant entity types.
+     # Delete everything connected to the key.
-     my @objects = ();
+     $self->Disconnect('HasValueFor', 'AttributeKey', $key);
-     if (! $entityName) {
-         push @objects, $self->GetEntityTypes();
-     } else {
-         push @objects, $entityName;
-     }
-     # Loop through the entity types.
-     for my $entityType (@objects) {
-         # Now check for this key in this entity.
-         my %secondaries = $self->GetSecondaryFields($entityType);
-         if (exists $secondaries{$key}) {
-             # We found it, so delete all the values of the key.
-             $self->DeleteValue($entityType, undef, $key);
-         }
-     }
      # Return a 1, for backward compatability.
      return 1;
  }
  =head3 GetAttributeKeys
- C<< my @keyList = $attrDB->GetAttributeKeys($entityName); >>
+ C<< my @keyList = $attrDB->GetAttributeKeys($groupName); >>
- Return a list of the attribute keys for a particular entity type.
+ Return a list of the attribute keys for a particular group.
  =over 4
- =item entityName
+ =item groupName
- Name of the entity whose keys are desired.
+ Name of the group whose keys are desired.
  =item RETURN
- Returns a list of the attribute keys for the specified entity.
+ Returns a list of the attribute keys for the specified group.
  =back
-Line 1408
+Line 1534
  sub GetAttributeKeys {
      # Get the parameters.
-     my ($self, $entityName) = @_;
+     my ($self, $groupName) = @_;
-     # Get the entity's secondary fields.
+     # Get the attributes for the specified group.
-     my %keyList = $self->GetSecondaryFields($entityName);
+     my @groups = $self->GetFlat(['IsInGroup'], "IsInGroup(to-link) = ?", [$groupName],
+                                 'IsInGroup(from-link)');
      # Return the keys.
-     return sort keys %keyList;
+     return sort @groups;
  }
 ;

 Legend:



Removed from v.1.9
 


changed lines


 
Added in v.1.17
 Legend:



Removed from v.1.9
 


changed lines


 
Added in v.1.17
-Removed from v.1.9
+Added in v.1.17

MCS Webmaster	ViewVC Help
Powered by ViewVC 1.0.3