Bio::EnsEMBL::Hive::DBSQL::AnalysisCtrlRuleAdaptor

  $AnalysisCtrlRuleAdaptor = $db_adaptor->get_AnalysisCtrlRuleAdaptor;
  $analysisCtrlRuleAdaptor = $analysisCtrlRuleObj->adaptor;

  Module to encapsulate all db access for persistent class AnalysisCtrlRule.
  There should be just one per application and database connection.

  my $self = shift;

  return qw (r.ctrled_analysis_id
             r.condition_analysis_url
            );

  my $self = shift;
  return '';

  my $self = shift;
  return '';
}

###############################################################################
#
# General access methods that could be moved
# into a superclass
#
###############################################################################

  my ($self, $constraint, $join) = @_;

  my @tables = $self->_tables;
  my $columns = join(', ', $self->_columns());

  if ($join) {
    foreach my $single_join (@{$join}) {
      my ($tablename, $condition, $extra_columns) = @{$single_join};
      if ($tablename && $condition) {
        push @tables, $tablename;

        if($constraint) {
          $constraint .= " AND $condition";
        } else {
          $constraint = " $condition";
        }
      }
      if ($extra_columns) {
        $columns .= ", " . join(', ', @{$extra_columns});
      }
    }
  }

  #construct a nice table string like 'table1 t1, table2 t2'
  my $tablenames = join(', ', map({ join(' ', @$_) } @tables));

  my $sql = "SELECT $columns FROM $tablenames";

  my $default_where = $self->_default_where_clause;
  my $final_clause = $self->_final_clause;

  #append a where clause if it was defined
  if($constraint) {
    $sql .= " WHERE $constraint ";
    if($default_where) {
      $sql .= " AND $default_where ";
    }
  } elsif($default_where) {
    $sql .= " WHERE $default_where ";
  }

  #append additional clauses which may have been defined
  $sql .= " $final_clause";

  my $sth = $self->prepare($sql);
  $sth->execute;

#  print STDERR $sql,"\n";

  return $self->_objs_from_sth($sth);
}


1;

  my ($self, $sth) = @_;
  my @rules = ();

  my ($ctrled_analysis_id, $condition_analysis_url);
  $sth->bind_columns(\$ctrled_analysis_id,\$ condition_analysis_url);

  while ($sth->fetch()) {
    my $rule = Bio::EnsEMBL::Hive::AnalysisCtrlRule->new;
    $rule->adaptor($self);
    $rule->ctrled_analysis_id($ctrled_analysis_id);
    $rule->condition_analysis_url($condition_analysis_url);
    push @rules, $rule;
  }
  return\@ rules;

  my $self = shift;

  return (['analysis_ctrl_rule', 'r']);

  my ($self, $conditionAnalysis, $ctrledAnalysis) = @_;

  return unless($conditionAnalysis and $ctrledAnalysis);
  
  my $rule = Bio::EnsEMBL::Hive::AnalysisCtrlRule->new();
  #must set ctrled_analysis first in order for internal logic to abreviate 'to_url'
  $rule->ctrled_analysis($ctrledAnalysis);
  $rule->condition_analysis($conditionAnalysis);
  
  $self->store($rule);
}

############################
#
# INTERNAL METHODS
# (pseudo subclass methods)
#
############################

#internal method used in multiple calls above to build objects from table data

  my $self = shift;
  return $self->_generic_fetch();

  my ($self,$id) = @_;

  unless(defined $id) {
    throw("fetch_by_ctrled_analysis_id must have an id");
  }

  my $constraint = "r.ctrled_analysis_id = $id";

  return $self->_generic_fetch($constraint);

  my ( $self, $condition_analysis_url ) = @_;

  my $sth = $self->prepare("DELETE FROM analysis_ctrl_rule WHERE condition_analysis_url =?");
  $sth->execute($condition_analysis_url);

  my ( $self, $rule ) = @_;

  #print("\nAnalysisCtrlRuleAdaptor->store()\n");
 
  my $sth = $self->prepare(q{INSERT ignore INTO analysis_ctrl_rule 
        (ctrled_analysis_id, condition_analysis_url) VALUES(?,?) });
  if($sth->execute($rule->ctrled_analysis_id, $rule->condition_analysis_url)) {
    $sth->finish();
  }
  $rule->adaptor( $self );

  Contact Jessica Severin on implemetation/design detail: jessica@ebi.ac.uk
  Contact Ewan Birney on EnsEMBL in general: birney@sanger.ac.uk

  The rest of the documentation details each of the object methods.
  Internal methods are usually preceded with a _