SomeTable:
  actAs:
    RandomUnique:
  columns:
    id: { type: integer(5), primary: true, autoincrement: true }
    user_id: { type: integer(4) }
    org_name: { type: string(100) }
    title: { type: string(20) }
    first_name: { type: string(50) }
    last_name: { type: string(50) }
    email: { type: string(128), notnull: true }

<?php
 
class RandomUnique extends Doctrine_Template
{
  public function setTableDefinition()
  {
    $column_name = 'unique_code';
    $column_size = 16;
    $this->hasColumn($column_name, 'string', $column_size, array('unique' => true, 'notnull' => true));
    $this->addListener(new RandomUniqueListener(array('column_name' => $column_name, 'column_size' => $column_size)));
  }
 
  public static function generateString($minlength, $maxlength, $useupper, $usespecial, $usenumbers)
  {
    /*
     Author: Peter Mugane Kionga-Kamau
     http://www.pmkmedia.com
 
     Description: string str_makerand(int $minlength, int $maxlength, bool $useupper, bool $usespecial, bool $usenumbers)
     returns a randomly generated string of length between $minlength and $maxlength inclusively.
 
     Notes:
     - If $useupper is true uppercase characters will be used; if false they will be excluded.
     - If $usespecial is true special characters will be used; if false they will be excluded.
     - If $usenumbers is true numerical characters will be used; if false they will be excluded.
     - If $minlength is equal to $maxlength a string of length $maxlength will be returned.
     - Not all special characters are included since they could cause parse errors with queries.
 
     Modify at will.
     */
    $charset = "abcdefghijklmnopqrstuvwxyz";
    if ($useupper) $charset .= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if ($usenumbers) $charset .= "0123456789";
    if ($usespecial) $charset .= "~@#$%^*()_+-={}|]["; // Note: using all special characters this reads: "~!@#$%^&*()_+`-={}|\\]?[\":;'><,./";
    if ($minlength > $maxlength) $length = mt_rand ($maxlength, $minlength);
    else $length = mt_rand ($minlength, $maxlength);
    $key = '';
    for ($i=0; $i<$length; $i++) 
      $key .= $charset[(mt_rand(0,(strlen($charset)-1)))];
    return $key;
  }
}

<?php
 
class RandomUniqueListener extends Doctrine_Record_Listener
{
  protected $column_name;
  protected $column_size;
 
  public function __construct($options)
  {
    $this->column_name = $options['column_name'];
    $this->column_size = $options['column_size'];
  }
 
  public function preInsert(Doctrine_Event $event)
  {
    $d = $event->getInvoker(); /* @var $d sfDoctrineRecord */
    $class_name = get_class($d);
    $i = 0;
    $s = null;
 
    $column_name = $this->column_name;
    $column_size = $this->column_size;
 
    while ($i < 100) // maximum 100 attempts
    {
      $s = RandomUnique::generateString($column_size, $column_size, false, false, true);
 
      $q = Doctrine_Query::create()
        ->select('t.id')
        ->from($class_name.' t')
        ->where('t.'.$column_name.'=?', $s);
 
      $result = $q->execute(array(), Doctrine::HYDRATE_ARRAY);
 
      // if we have found a unique code (e.g.: is not used, does not exist in the table)
      if (!$result || count($result) < 0) break;
 
      $i++;
    }
 
    $event->getInvoker()->$column_name = $s;
  }
}

<?php
 
class yourForm extends sfForm
{
  function configure()
  {
    $this->setWidgets(array(
      'first_name'           => new sfWidgetFormInput(array(), array('maxlength' => 50)),
      'last_name'            => new sfWidgetFormInput(array(), array('maxlength' => 50)),
      'email'                => new sfWidgetFormInput(array(), array('maxlength' => 128)),
    ));
 
    $this->setValidators(array(
      'first_name'           => new sfValidatorString(array('max_length' => 50, 'required' => true)),
      'last_name'            => new sfValidatorString(array('max_length' => 50, 'required' => false)),
      'email'                => new sfValidatorEmail(array('max_length' => 128, 'required' => true)),
    ));
 
    $decorator = new sidFormFormatter($this->widgetSchema, $this->validatorSchema);
    $this->widgetSchema->addFormFormatter('custom', $decorator);
    $this->widgetSchema->setFormFormatterName('custom');    
  }
}

em.required {font-size:1.2em;font-weight:bold;margin:0px;padding:0px;}
label.required {font-weight:bold;}

<?php
 
class sidFormFormatter extends sfWidgetFormSchemaFormatter {
 
  protected 
    $rowFormat = "\n%error%\n<div class=\"formRow\">\n<div class=\"formLabel\">%label%</div>\n<div class=\"formField\">%field%\n%help%</div></div>\n%hidden_fields%",
    $helpFormat = '<div class="fieldHelp">%help%</div>', 
    $errorRowFormat = "<div>\n%errors%<br /></div>\n", 
    $errorListFormatInARow = "<ul>%errors%</ul>\n", 
    $errorRowFormatInARow =  "<li class=\"error\">&darr; %error% &darr;</li>\n", 
    $namedErrorRowFormatInARow = "<li class=\"error\">&darr; %error% &darr;</li>\n", 
    $decoratorFormat = "%content%";
 
  /**
   * @var sfValidatorSchema
   */
  protected $validatorSchema = null;
 
  /**
   * @var array
   */
  protected $params = array();
 
  /**
   * Constructor
   *
   * Params:
   *  - "required_label_class_name" css class name for label tag when the field is required field, the default is 'required'.
   *  - "required_label_format" default is '%label% <em class="required">*</em>'.
   *
   * @param sfWidgetFormSchema $widgetSchema
   * @param sfValidatorSchema $validatorSchema
   * @param array $params
   */
  public function __construct(sfWidgetFormSchema $widgetSchema, sfValidatorSchema $validatorSchema, $params = array())
  {
    $this->validatorSchema = $validatorSchema;
    $this->params = $params;
    parent::__construct($widgetSchema);
  }
 
  /**
   * Returns parameter identified with $name or if does not exist, returns $default.
   *
   * @param string $name
   * @param mixed $default
   * @return mixed
   */
  public function getParameter($name, $default=null)
  {
    if (!isset($this->params[$name]))
    {
      return $default;
    }
 
    return $this->params[$name];
  }
 
  /**
   * Generates a label for the given field name.
   *
   * @param  string $name        The field name
   * @param  array  $attributes  Optional html attributes for the label tag
   *
   * @return string The label tag
   */
  public function generateLabel($name, $attributes = array())
  {
    $is_required = false;
    if ( $this->validatorSchema and isset($this->validatorSchema[$name]) )
    {
      $validator = $this->validatorSchema[$name];
      /* @var $validator sfValidatorBase */
 
      if ( $validator->getOption('required') )
      {
        $class_name = $this->getParameter('required_label_class_name', 'required');
        if (isset($attributes['class'])) $attributes['class'] .= ' '.$class_name; else $attributes['class'] = $class_name;
        $is_required = true;
      }
    }
 
    $s = parent::generateLabel($name, $attributes);
 
    if ($is_required)
    {
      $format = $this->getParameter('required_label_format', '%label% <em class="required">*</em>');
      $s = str_replace('%label%', $s, $format);
    }
 
    return $s;
  }
}