Anonymous avatar Anonymous committed b530fbe

initial import

Comments (0)

Files changed (17)

+/*.tgz
+package.xml
+Copyright (c) 2009 Matteo Giachino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# sfPropel15RatableBehaviorPlugin
+
+A ratable behavior based on Propel 15
+
+## Introduction
+
+This plugins depends on sfPropel15Plugin
+
+## Features
+
+  * designed for the magical propel 1.5
+  * easy integration in your model
+  * add a new table to your db for rating, so don't mess with your data.
+  * the base idea is from the nice sfPropelActAsRatable
+
+## Get it installed
+
+  * be sure to have sfPropel15Plugin installed and enabled
+  
+  * go to your project's root
+
+  * Install the plugin:
+
+         ./symfony plugin:install sfPropel15RatableBehaviorPlugin
+
+  * rebuild your model
+
+	 ./symfony propel:build-all-load --no-confirmation
+
+  * clear your cache:
+
+         ./symfony cc
+
+
+## Usage
+
+### Enable the behavior in your schema
+
+
+    [yaml]
+    article:
+      id:  ~
+      title:                 { type: varchar(150), required: true }
+      html_text:             { type: longvarchar }
+    propel_behavior:
+      ratable:               ~
+
+### Rebuild your model
+
+### Enjoy!
+
+    [php]
+    // $object->setRating($vote, $user_id = null, PropelPDO $con = null);
+    // $vote is an integer value from 1 to 5
+    // $user_id a unique id (usually the id from sf_guard_user table)
+    // use it if you want to allow one vote, per object, per user.
+    // if no user_id is provided votes are free
+    
+    // $object->getRating($max = 5, $round = false)
+    // $max is the maximum vote
+    // $round whether to round the result or not
+    
+    // create the article object
+    $art = new Article();
+    // set vote 4 on 5 to article $art by user_id 1
+    $art->setRating(4, 1); // return 4
+    // set vote 2 on 5 to article $art by user_id 2
+    $art->setRating(2, 2); // return 3
+    // set a duplicate vote
+    $art->setRating(3, 2); // no vote is set. return false
+    
+    // get the average
+    $art->getRating() // return 3
+    // get the average, with maxiumum at 10.
+    $art->getRating(10) // return 6
+
+
+## License and credits
+This plugin has been developed by Matteo Giachino and is licensed under the MIT license.

README con immagine

+# sfPropel15RatableBehaviorPlugin
+
+A ratable behavior based on Propel 15
+![ss1.png](http://trac.symfony-project.org/attachment/wiki/sfPropelTaggableWidgetPlugin/ss1.png?format=raw)
+
+## Introduction
+
+This plugins depends on sfPropel15Plugin
+
+## Features
+
+  * designed for the magical propel 1.5
+  * easy integration in your model
+  * add a new table to your db for rating, so don't mess with your data.
+  * the base idea is from the nice sfPropelActAsRatable
+
+## Get it installed
+
+  * be sure to have sfPropel15Plugin installed and enabled
+  
+  * go to your project's root
+
+  * Install the plugin:
+
+         ./symfony plugin:install sfPropel15RatableBehaviorPlugin
+
+  * rebuild your model
+
+	 ./symfony propel:build-all-load --no-confirmation
+
+  * clear your cache:
+
+         ./symfony cc
+
+
+## Usage
+
+### Enable the behavior in your schema
+
+
+    [yaml]
+    article:
+      id:  ~
+      title:                 { type: varchar(150), required: true }
+      html_text:             { type: longvarchar }
+    propel_behavior:
+      ratable:               ~
+
+### Rebuild your model
+
+### Enjoy!
+
+    [php]
+    // $object->setRating($vote, $user_id = null, PropelPDO $con = null);
+    // $vote is an integer value from 1 to 5
+    // $user_id a unique id (usually the id from sf_guard_user table)
+    // use it if you want to allow one vote, per object, per user.
+    // if no user_id is provided votes are free
+    
+    // $object->getRating($max = 5, $round = false)
+    // $max is the maximum vote
+    // $round whether to round the result or not
+    
+    // set vote 4 on 5 to article $art by user_id 1
+    $art = new Article();
+    $art->setRating(4, 1);
+    $art->setRating(2, 2);
+
+    // get the average
+    $art->getRating() // 3
+    $art->getRating(10) // 6
+
+
+## License and credits
+This plugin has been developed by Matteo Giachino and is licensed under the MIT license.

config/schema.yml

+# Yml compilato da Matteo
+package: plugins.sfPropel15RatableBehaviorPlugin.lib.model
+
+
+classes:
+  sfRatable:
+    columns:
+      id:            ~
+      ratable_model: { type: varchar(50), required: true }
+      ratable_id:    { type: integer, required: true }
+      user_id:       { type: integer, required: false, default: ~ }
+      rating:        { type: integer }
+    propel_behaviors:
+      timestampable:   ~

lib/behavior/RatableBehavior.php

+<?php
+/**
+ * Ratable behavior for propel 1.5
+ *
+ * @author Matteo Giachino
+ */
+class RatableBehavior extends Behavior
+{
+  protected $parameters = array(
+  );
+
+
+  public function objectMethods()
+  {
+    $script = '';
+    $script .= $this->generateSetRatingMethod();
+    $script .= $this->generateGetRatingMethod();
+    return $script;
+  }
+
+
+
+  protected function generateSetRatingMethod()
+  {
+    $table = new Table();
+    $table = $this->getTable();
+    $rateTable = $this->getTable()->getDatabase()->getTable($this->getParameter('ratable'));
+    return "
+/**
+ * Rate a propel object with ratable behavior
+ *
+ * @return average rating if vote is ok, false for duplicate votes.
+ */
+public function setRating(\$vote, \$user_id = null, PropelPDO \$con = null) {
+  if (!in_array(\$vote, array(1, 2, 3, 4, 5))) {
+    throw new InvalidArgumentException('You must provide a vote from 1 to 5, no float number allowed');
+  }
+
+  // no need to check for vote consistency
+  if (\$user_id === null) {
+    \$rate = new sfRatable();
+    \$rate->setRatableModel('{$table->getPhpName()}');
+    \$rate->setRatableId(\$this->id);
+    \$rate->setRating(\$vote);
+    \$rate->save();
+    return \$this->getRating();
+  }
+
+  \$alreadyVoted = sfRatableQuery::create()
+    ->filterByUserId(\$user_id)
+    ->filterByRatableModel('{$table->getPhpName()}')
+    ->filterByRatableId(\$this->id)
+    ->count() == 1;
+  if (\$alreadyVoted) {
+    return false;
+  }
+
+  \$rate = new sfRatable();
+  \$rate->setUserId(\$user_id);
+  \$rate->setRatableModel('{$table->getPhpName()}');
+  \$rate->setRatableId(\$this->getId());
+  \$rate->setRating(\$vote);
+  \$rate->save();
+  return \$this->getRating();
+}
+";
+  }
+
+  protected function generateGetRatingMethod()
+  {
+    $rateTable = $this->getTable()->getDatabase()->getTable($this->getParameter('ratable'));
+    $table = $this->getTable();
+    return "
+/**
+ * Get the average rate for a Propel object with ratable behavior
+ * @int \$max      The maximum vote
+ * @bool \$round   Round result
+ *
+ * @return \$vote or null
+ */
+public function getRating(\$max = 5, \$round = false) {
+  if (\$max < 5) {
+    throw new InvalidArgumentException('The minimum value for \$max in getRating() method should be >= 5');
+  }
+
+  \$ratables = sfRatableQuery::create()
+    ->filterByRatableModel('{$table->getPhpName()}')
+    ->filterByRatableId(\$this->id)
+    ->find();
+  if (count(\$ratables) == 0) {
+    return null;
+  }
+  \$sum = 0;
+  foreach (\$ratables as \$ratable) {
+    \$sum += \$ratable->getRating();
+  }
+  \$avg = (\$sum / count(\$ratables)) * (\$max / 5);
+  return \$round ? round(\$avg) : \$avg;
+}
+";
+  }
+}
+

lib/filter/base/BasesfRatableFormFilter.class.php

+<?php
+
+/**
+ * sfRatable filter form base class.
+ *
+ * @package    ##PROJECT_NAME##
+ * @subpackage filter
+ * @author     ##AUTHOR_NAME##
+ */
+abstract class BasesfRatableFormFilter extends BaseFormFilterPropel
+{
+  public function setup()
+  {
+    $this->setWidgets(array(
+      'ratable_model' => new sfWidgetFormFilterInput(array('with_empty' => false)),
+      'ratable_id'    => new sfWidgetFormFilterInput(array('with_empty' => false)),
+      'user_id'       => new sfWidgetFormFilterInput(),
+      'rating'        => new sfWidgetFormFilterInput(),
+      'created_at'    => new sfWidgetFormFilterDate(array('from_date' => new sfWidgetFormDate(), 'to_date' => new sfWidgetFormDate())),
+      'updated_at'    => new sfWidgetFormFilterDate(array('from_date' => new sfWidgetFormDate(), 'to_date' => new sfWidgetFormDate())),
+    ));
+
+    $this->setValidators(array(
+      'ratable_model' => new sfValidatorPass(array('required' => false)),
+      'ratable_id'    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
+      'user_id'       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
+      'rating'        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
+      'created_at'    => new sfValidatorDateRange(array('required' => false, 'from_date' => new sfValidatorDate(array('required' => false)), 'to_date' => new sfValidatorDate(array('required' => false)))),
+      'updated_at'    => new sfValidatorDateRange(array('required' => false, 'from_date' => new sfValidatorDate(array('required' => false)), 'to_date' => new sfValidatorDate(array('required' => false)))),
+    ));
+
+    $this->widgetSchema->setNameFormat('sf_ratable_filters[%s]');
+
+    $this->errorSchema = new sfValidatorErrorSchema($this->validatorSchema);
+
+    parent::setup();
+  }
+
+  public function getModelName()
+  {
+    return 'sfRatable';
+  }
+
+  public function getFields()
+  {
+    return array(
+      'id'            => 'Number',
+      'ratable_model' => 'Text',
+      'ratable_id'    => 'Number',
+      'user_id'       => 'Number',
+      'rating'        => 'Number',
+      'created_at'    => 'Date',
+      'updated_at'    => 'Date',
+    );
+  }
+}

lib/filter/sfRatableFormFilter.class.php

+<?php
+
+/**
+ * sfRatable filter form.
+ *
+ * @package    ##PROJECT_NAME##
+ * @subpackage filter
+ * @author     ##AUTHOR_NAME##
+ */
+class sfRatableFormFilter extends BasesfRatableFormFilter
+{
+  public function configure()
+  {
+  }
+}

lib/form/base/BasesfRatableForm.class.php

+<?php
+
+/**
+ * sfRatable form base class.
+ *
+ * @method sfRatable getObject() Returns the current form's model object
+ *
+ * @package    ##PROJECT_NAME##
+ * @subpackage form
+ * @author     ##AUTHOR_NAME##
+ */
+abstract class BasesfRatableForm extends BaseFormPropel
+{
+  public function setup()
+  {
+    $this->setWidgets(array(
+      'id'            => new sfWidgetFormInputHidden(),
+      'ratable_model' => new sfWidgetFormInputText(),
+      'ratable_id'    => new sfWidgetFormInputText(),
+      'user_id'       => new sfWidgetFormInputText(),
+      'rating'        => new sfWidgetFormInputText(),
+      'created_at'    => new sfWidgetFormDateTime(),
+      'updated_at'    => new sfWidgetFormDateTime(),
+    ));
+
+    $this->setValidators(array(
+      'id'            => new sfValidatorPropelChoice(array('model' => 'sfRatable', 'column' => 'id', 'required' => false)),
+      'ratable_model' => new sfValidatorString(array('max_length' => 50)),
+      'ratable_id'    => new sfValidatorInteger(array('min' => -2147483648, 'max' => 2147483647)),
+      'user_id'       => new sfValidatorInteger(array('min' => -2147483648, 'max' => 2147483647, 'required' => false)),
+      'rating'        => new sfValidatorInteger(array('min' => -2147483648, 'max' => 2147483647, 'required' => false)),
+      'created_at'    => new sfValidatorDateTime(array('required' => false)),
+      'updated_at'    => new sfValidatorDateTime(array('required' => false)),
+    ));
+
+    $this->widgetSchema->setNameFormat('sf_ratable[%s]');
+
+    $this->errorSchema = new sfValidatorErrorSchema($this->validatorSchema);
+
+    parent::setup();
+  }
+
+  public function getModelName()
+  {
+    return 'sfRatable';
+  }
+
+
+}

lib/form/sfRatableForm.class.php

+<?php
+
+/**
+ * sfRatable form.
+ *
+ * @package    ##PROJECT_NAME##
+ * @subpackage form
+ * @author     ##AUTHOR_NAME##
+ */
+class sfRatableForm extends BasesfRatableForm
+{
+  public function configure()
+  {
+  }
+}

lib/model/map/sfRatableTableMap.php

+<?php
+
+
+
+/**
+ * This class defines the structure of the 'sf_ratable' table.
+ *
+ *
+ * This class was autogenerated by Propel 1.5.3-dev on:
+ *
+ * Tue Jul 13 14:46:38 2010
+ *
+ *
+ * This map class is used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    propel.generator.plugins.sfPropel15RatableBehaviorPlugin.lib.model.map
+ */
+class sfRatableTableMap extends TableMap {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'plugins.sfPropel15RatableBehaviorPlugin.lib.model.map.sfRatableTableMap';
+
+	/**
+	 * Initialize the table attributes, columns and validators
+	 * Relations are not initialized by this method since they are lazy loaded
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function initialize()
+	{
+	  // attributes
+		$this->setName('sf_ratable');
+		$this->setPhpName('sfRatable');
+		$this->setClassname('sfRatable');
+		$this->setPackage('plugins.sfPropel15RatableBehaviorPlugin.lib.model');
+		$this->setUseIdGenerator(true);
+		// columns
+		$this->addPrimaryKey('ID', 'Id', 'INTEGER', true, null, null);
+		$this->addColumn('RATABLE_MODEL', 'RatableModel', 'VARCHAR', true, 50, null);
+		$this->addColumn('RATABLE_ID', 'RatableId', 'INTEGER', true, null, null);
+		$this->addColumn('USER_ID', 'UserId', 'INTEGER', false, null, null);
+		$this->addColumn('RATING', 'Rating', 'INTEGER', false, null, null);
+		$this->addColumn('CREATED_AT', 'CreatedAt', 'TIMESTAMP', false, null, null);
+		$this->addColumn('UPDATED_AT', 'UpdatedAt', 'TIMESTAMP', false, null, null);
+		// validators
+	} // initialize()
+
+	/**
+	 * Build the RelationMap objects for this table relationships
+	 */
+	public function buildRelations()
+	{
+	} // buildRelations()
+
+	/**
+	 * 
+	 * Gets the list of behaviors registered for this table
+	 * 
+	 * @return array Associative array (name => parameters) of behaviors
+	 */
+	public function getBehaviors()
+	{
+		return array(
+			'timestampable' => array('create_column' => 'created_at', 'update_column' => 'updated_at', ),
+			'symfony' => array('form' => 'true', 'filter' => 'true', ),
+			'symfony_behaviors' => array(),
+		);
+	} // getBehaviors()
+
+} // sfRatableTableMap

lib/model/om/BasesfRatable.php

+<?php
+
+
+/**
+ * Base class that represents a row from the 'sf_ratable' table.
+ *
+ * 
+ *
+ * This class was autogenerated by Propel 1.5.3-dev on:
+ *
+ * Tue Jul 13 14:46:38 2010
+ *
+ * @package    propel.generator.plugins.sfPropel15RatableBehaviorPlugin.lib.model.om
+ */
+abstract class BasesfRatable extends BaseObject  implements Persistent
+{
+
+	/**
+	 * Peer class name
+	 */
+  const PEER = 'sfRatablePeer';
+
+	/**
+	 * The Peer class.
+	 * Instance provides a convenient way of calling static methods on a class
+	 * that calling code may not be able to identify.
+	 * @var        sfRatablePeer
+	 */
+	protected static $peer;
+
+	/**
+	 * The value for the id field.
+	 * @var        int
+	 */
+	protected $id;
+
+	/**
+	 * The value for the ratable_model field.
+	 * @var        string
+	 */
+	protected $ratable_model;
+
+	/**
+	 * The value for the ratable_id field.
+	 * @var        int
+	 */
+	protected $ratable_id;
+
+	/**
+	 * The value for the user_id field.
+	 * @var        int
+	 */
+	protected $user_id;
+
+	/**
+	 * The value for the rating field.
+	 * @var        int
+	 */
+	protected $rating;
+
+	/**
+	 * The value for the created_at field.
+	 * @var        string
+	 */
+	protected $created_at;
+
+	/**
+	 * The value for the updated_at field.
+	 * @var        string
+	 */
+	protected $updated_at;
+
+	/**
+	 * Flag to prevent endless save loop, if this object is referenced
+	 * by another object which falls in this transaction.
+	 * @var        boolean
+	 */
+	protected $alreadyInSave = false;
+
+	/**
+	 * Flag to prevent endless validation loop, if this object is referenced
+	 * by another object which falls in this transaction.
+	 * @var        boolean
+	 */
+	protected $alreadyInValidation = false;
+
+	/**
+	 * Get the [id] column value.
+	 * 
+	 * @return     int
+	 */
+	public function getId()
+	{
+		return $this->id;
+	}
+
+	/**
+	 * Get the [ratable_model] column value.
+	 * 
+	 * @return     string
+	 */
+	public function getRatableModel()
+	{
+		return $this->ratable_model;
+	}
+
+	/**
+	 * Get the [ratable_id] column value.
+	 * 
+	 * @return     int
+	 */
+	public function getRatableId()
+	{
+		return $this->ratable_id;
+	}
+
+	/**
+	 * Get the [user_id] column value.
+	 * 
+	 * @return     int
+	 */
+	public function getUserId()
+	{
+		return $this->user_id;
+	}
+
+	/**
+	 * Get the [rating] column value.
+	 * 
+	 * @return     int
+	 */
+	public function getRating()
+	{
+		return $this->rating;
+	}
+
+	/**
+	 * Get the [optionally formatted] temporal [created_at] column value.
+	 * 
+	 *
+	 * @param      string $format The date/time format string (either date()-style or strftime()-style).
+	 *							If format is NULL, then the raw DateTime object will be returned.
+	 * @return     mixed Formatted date/time value as string or DateTime object (if format is NULL), NULL if column is NULL, and 0 if column value is 0000-00-00 00:00:00
+	 * @throws     PropelException - if unable to parse/validate the date/time value.
+	 */
+	public function getCreatedAt($format = 'Y-m-d H:i:s')
+	{
+		if ($this->created_at === null) {
+			return null;
+		}
+
+
+		if ($this->created_at === '0000-00-00 00:00:00') {
+			// while technically this is not a default value of NULL,
+			// this seems to be closest in meaning.
+			return null;
+		} else {
+			try {
+				$dt = new DateTime($this->created_at);
+			} catch (Exception $x) {
+				throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
+			}
+		}
+
+		if ($format === null) {
+			// Because propel.useDateTimeClass is TRUE, we return a DateTime object.
+			return $dt;
+		} elseif (strpos($format, '%') !== false) {
+			return strftime($format, $dt->format('U'));
+		} else {
+			return $dt->format($format);
+		}
+	}
+
+	/**
+	 * Get the [optionally formatted] temporal [updated_at] column value.
+	 * 
+	 *
+	 * @param      string $format The date/time format string (either date()-style or strftime()-style).
+	 *							If format is NULL, then the raw DateTime object will be returned.
+	 * @return     mixed Formatted date/time value as string or DateTime object (if format is NULL), NULL if column is NULL, and 0 if column value is 0000-00-00 00:00:00
+	 * @throws     PropelException - if unable to parse/validate the date/time value.
+	 */
+	public function getUpdatedAt($format = 'Y-m-d H:i:s')
+	{
+		if ($this->updated_at === null) {
+			return null;
+		}
+
+
+		if ($this->updated_at === '0000-00-00 00:00:00') {
+			// while technically this is not a default value of NULL,
+			// this seems to be closest in meaning.
+			return null;
+		} else {
+			try {
+				$dt = new DateTime($this->updated_at);
+			} catch (Exception $x) {
+				throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
+			}
+		}
+
+		if ($format === null) {
+			// Because propel.useDateTimeClass is TRUE, we return a DateTime object.
+			return $dt;
+		} elseif (strpos($format, '%') !== false) {
+			return strftime($format, $dt->format('U'));
+		} else {
+			return $dt->format($format);
+		}
+	}
+
+	/**
+	 * Set the value of [id] column.
+	 * 
+	 * @param      int $v new value
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setId($v)
+	{
+		if ($v !== null) {
+			$v = (int) $v;
+		}
+
+		if ($this->id !== $v) {
+			$this->id = $v;
+			$this->modifiedColumns[] = sfRatablePeer::ID;
+		}
+
+		return $this;
+	} // setId()
+
+	/**
+	 * Set the value of [ratable_model] column.
+	 * 
+	 * @param      string $v new value
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setRatableModel($v)
+	{
+		if ($v !== null) {
+			$v = (string) $v;
+		}
+
+		if ($this->ratable_model !== $v) {
+			$this->ratable_model = $v;
+			$this->modifiedColumns[] = sfRatablePeer::RATABLE_MODEL;
+		}
+
+		return $this;
+	} // setRatableModel()
+
+	/**
+	 * Set the value of [ratable_id] column.
+	 * 
+	 * @param      int $v new value
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setRatableId($v)
+	{
+		if ($v !== null) {
+			$v = (int) $v;
+		}
+
+		if ($this->ratable_id !== $v) {
+			$this->ratable_id = $v;
+			$this->modifiedColumns[] = sfRatablePeer::RATABLE_ID;
+		}
+
+		return $this;
+	} // setRatableId()
+
+	/**
+	 * Set the value of [user_id] column.
+	 * 
+	 * @param      int $v new value
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setUserId($v)
+	{
+		if ($v !== null) {
+			$v = (int) $v;
+		}
+
+		if ($this->user_id !== $v) {
+			$this->user_id = $v;
+			$this->modifiedColumns[] = sfRatablePeer::USER_ID;
+		}
+
+		return $this;
+	} // setUserId()
+
+	/**
+	 * Set the value of [rating] column.
+	 * 
+	 * @param      int $v new value
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setRating($v)
+	{
+		if ($v !== null) {
+			$v = (int) $v;
+		}
+
+		if ($this->rating !== $v) {
+			$this->rating = $v;
+			$this->modifiedColumns[] = sfRatablePeer::RATING;
+		}
+
+		return $this;
+	} // setRating()
+
+	/**
+	 * Sets the value of [created_at] column to a normalized version of the date/time value specified.
+	 * 
+	 * @param      mixed $v string, integer (timestamp), or DateTime value.  Empty string will
+	 *						be treated as NULL for temporal objects.
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setCreatedAt($v)
+	{
+		// we treat '' as NULL for temporal objects because DateTime('') == DateTime('now')
+		// -- which is unexpected, to say the least.
+		if ($v === null || $v === '') {
+			$dt = null;
+		} elseif ($v instanceof DateTime) {
+			$dt = $v;
+		} else {
+			// some string/numeric value passed; we normalize that so that we can
+			// validate it.
+			try {
+				if (is_numeric($v)) { // if it's a unix timestamp
+					$dt = new DateTime('@'.$v, new DateTimeZone('UTC'));
+					// We have to explicitly specify and then change the time zone because of a
+					// DateTime bug: http://bugs.php.net/bug.php?id=43003
+					$dt->setTimeZone(new DateTimeZone(date_default_timezone_get()));
+				} else {
+					$dt = new DateTime($v);
+				}
+			} catch (Exception $x) {
+				throw new PropelException('Error parsing date/time value: ' . var_export($v, true), $x);
+			}
+		}
+
+		if ( $this->created_at !== null || $dt !== null ) {
+			// (nested ifs are a little easier to read in this case)
+
+			$currNorm = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
+			$newNorm = ($dt !== null) ? $dt->format('Y-m-d H:i:s') : null;
+
+			if ( ($currNorm !== $newNorm) // normalized values don't match 
+					)
+			{
+				$this->created_at = ($dt ? $dt->format('Y-m-d H:i:s') : null);
+				$this->modifiedColumns[] = sfRatablePeer::CREATED_AT;
+			}
+		} // if either are not null
+
+		return $this;
+	} // setCreatedAt()
+
+	/**
+	 * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
+	 * 
+	 * @param      mixed $v string, integer (timestamp), or DateTime value.  Empty string will
+	 *						be treated as NULL for temporal objects.
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function setUpdatedAt($v)
+	{
+		// we treat '' as NULL for temporal objects because DateTime('') == DateTime('now')
+		// -- which is unexpected, to say the least.
+		if ($v === null || $v === '') {
+			$dt = null;
+		} elseif ($v instanceof DateTime) {
+			$dt = $v;
+		} else {
+			// some string/numeric value passed; we normalize that so that we can
+			// validate it.
+			try {
+				if (is_numeric($v)) { // if it's a unix timestamp
+					$dt = new DateTime('@'.$v, new DateTimeZone('UTC'));
+					// We have to explicitly specify and then change the time zone because of a
+					// DateTime bug: http://bugs.php.net/bug.php?id=43003
+					$dt->setTimeZone(new DateTimeZone(date_default_timezone_get()));
+				} else {
+					$dt = new DateTime($v);
+				}
+			} catch (Exception $x) {
+				throw new PropelException('Error parsing date/time value: ' . var_export($v, true), $x);
+			}
+		}
+
+		if ( $this->updated_at !== null || $dt !== null ) {
+			// (nested ifs are a little easier to read in this case)
+
+			$currNorm = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
+			$newNorm = ($dt !== null) ? $dt->format('Y-m-d H:i:s') : null;
+
+			if ( ($currNorm !== $newNorm) // normalized values don't match 
+					)
+			{
+				$this->updated_at = ($dt ? $dt->format('Y-m-d H:i:s') : null);
+				$this->modifiedColumns[] = sfRatablePeer::UPDATED_AT;
+			}
+		} // if either are not null
+
+		return $this;
+	} // setUpdatedAt()
+
+	/**
+	 * Indicates whether the columns in this object are only set to default values.
+	 *
+	 * This method can be used in conjunction with isModified() to indicate whether an object is both
+	 * modified _and_ has some values set which are non-default.
+	 *
+	 * @return     boolean Whether the columns in this object are only been set with default values.
+	 */
+	public function hasOnlyDefaultValues()
+	{
+		// otherwise, everything was equal, so return TRUE
+		return true;
+	} // hasOnlyDefaultValues()
+
+	/**
+	 * Hydrates (populates) the object variables with values from the database resultset.
+	 *
+	 * An offset (0-based "start column") is specified so that objects can be hydrated
+	 * with a subset of the columns in the resultset rows.  This is needed, for example,
+	 * for results of JOIN queries where the resultset row includes columns from two or
+	 * more tables.
+	 *
+	 * @param      array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
+	 * @param      int $startcol 0-based offset column which indicates which restultset column to start with.
+	 * @param      boolean $rehydrate Whether this object is being re-hydrated from the database.
+	 * @return     int next starting column
+	 * @throws     PropelException  - Any caught Exception will be rewrapped as a PropelException.
+	 */
+	public function hydrate($row, $startcol = 0, $rehydrate = false)
+	{
+		try {
+
+			$this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
+			$this->ratable_model = ($row[$startcol + 1] !== null) ? (string) $row[$startcol + 1] : null;
+			$this->ratable_id = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
+			$this->user_id = ($row[$startcol + 3] !== null) ? (int) $row[$startcol + 3] : null;
+			$this->rating = ($row[$startcol + 4] !== null) ? (int) $row[$startcol + 4] : null;
+			$this->created_at = ($row[$startcol + 5] !== null) ? (string) $row[$startcol + 5] : null;
+			$this->updated_at = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
+			$this->resetModified();
+
+			$this->setNew(false);
+
+			if ($rehydrate) {
+				$this->ensureConsistency();
+			}
+
+			return $startcol + 7; // 7 = sfRatablePeer::NUM_COLUMNS - sfRatablePeer::NUM_LAZY_LOAD_COLUMNS).
+
+		} catch (Exception $e) {
+			throw new PropelException("Error populating sfRatable object", $e);
+		}
+	}
+
+	/**
+	 * Checks and repairs the internal consistency of the object.
+	 *
+	 * This method is executed after an already-instantiated object is re-hydrated
+	 * from the database.  It exists to check any foreign keys to make sure that
+	 * the objects related to the current object are correct based on foreign key.
+	 *
+	 * You can override this method in the stub class, but you should always invoke
+	 * the base method from the overridden method (i.e. parent::ensureConsistency()),
+	 * in case your model changes.
+	 *
+	 * @throws     PropelException
+	 */
+	public function ensureConsistency()
+	{
+
+	} // ensureConsistency
+
+	/**
+	 * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
+	 *
+	 * This will only work if the object has been saved and has a valid primary key set.
+	 *
+	 * @param      boolean $deep (optional) Whether to also de-associated any related objects.
+	 * @param      PropelPDO $con (optional) The PropelPDO connection to use.
+	 * @return     void
+	 * @throws     PropelException - if this object is deleted, unsaved or doesn't have pk match in db
+	 */
+	public function reload($deep = false, PropelPDO $con = null)
+	{
+		if ($this->isDeleted()) {
+			throw new PropelException("Cannot reload a deleted object.");
+		}
+
+		if ($this->isNew()) {
+			throw new PropelException("Cannot reload an unsaved object.");
+		}
+
+		if ($con === null) {
+			$con = Propel::getConnection(sfRatablePeer::DATABASE_NAME, Propel::CONNECTION_READ);
+		}
+
+		// We don't need to alter the object instance pool; we're just modifying this instance
+		// already in the pool.
+
+		$stmt = sfRatablePeer::doSelectStmt($this->buildPkeyCriteria(), $con);
+		$row = $stmt->fetch(PDO::FETCH_NUM);
+		$stmt->closeCursor();
+		if (!$row) {
+			throw new PropelException('Cannot find matching row in the database to reload object values.');
+		}
+		$this->hydrate($row, 0, true); // rehydrate
+
+		if ($deep) {  // also de-associate any related objects?
+
+		} // if (deep)
+	}
+
+	/**
+	 * Removes this object from datastore and sets delete attribute.
+	 *
+	 * @param      PropelPDO $con
+	 * @return     void
+	 * @throws     PropelException
+	 * @see        BaseObject::setDeleted()
+	 * @see        BaseObject::isDeleted()
+	 */
+	public function delete(PropelPDO $con = null)
+	{
+		if ($this->isDeleted()) {
+			throw new PropelException("This object has already been deleted.");
+		}
+
+		if ($con === null) {
+			$con = Propel::getConnection(sfRatablePeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+		}
+		
+		$con->beginTransaction();
+		try {
+			$ret = $this->preDelete($con);
+			// symfony_behaviors behavior
+			foreach (sfMixer::getCallables('BasesfRatable:delete:pre') as $callable)
+			{
+			  if (call_user_func($callable, $this, $con))
+			  {
+			    $con->commit();
+			    return;
+			  }
+			}
+
+			if ($ret) {
+				sfRatableQuery::create()
+					->filterByPrimaryKey($this->getPrimaryKey())
+					->delete($con);
+				$this->postDelete($con);
+				// symfony_behaviors behavior
+				foreach (sfMixer::getCallables('BasesfRatable:delete:post') as $callable)
+				{
+				  call_user_func($callable, $this, $con);
+				}
+
+				$con->commit();
+				$this->setDeleted(true);
+			} else {
+				$con->commit();
+			}
+		} catch (PropelException $e) {
+			$con->rollBack();
+			throw $e;
+		}
+	}
+
+	/**
+	 * Persists this object to the database.
+	 *
+	 * If the object is new, it inserts it; otherwise an update is performed.
+	 * All modified related objects will also be persisted in the doSave()
+	 * method.  This method wraps all precipitate database operations in a
+	 * single transaction.
+	 *
+	 * @param      PropelPDO $con
+	 * @return     int The number of rows affected by this insert/update and any referring fk objects' save() operations.
+	 * @throws     PropelException
+	 * @see        doSave()
+	 */
+	public function save(PropelPDO $con = null)
+	{
+		if ($this->isDeleted()) {
+			throw new PropelException("You cannot save an object that has been deleted.");
+		}
+
+		if ($con === null) {
+			$con = Propel::getConnection(sfRatablePeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
+		}
+		
+		$con->beginTransaction();
+		$isInsert = $this->isNew();
+		try {
+			$ret = $this->preSave($con);
+			// symfony_behaviors behavior
+			foreach (sfMixer::getCallables('BasesfRatable:save:pre') as $callable)
+			{
+			  if (is_integer($affectedRows = call_user_func($callable, $this, $con)))
+			  {
+			  	$con->commit();
+			    return $affectedRows;
+			  }
+			}
+
+			if ($isInsert) {
+				$ret = $ret && $this->preInsert($con);
+				// timestampable behavior
+				if (!$this->isColumnModified(sfRatablePeer::CREATED_AT)) {
+					$this->setCreatedAt(time());
+				}
+				if (!$this->isColumnModified(sfRatablePeer::UPDATED_AT)) {
+					$this->setUpdatedAt(time());
+				}
+			} else {
+				$ret = $ret && $this->preUpdate($con);
+				// timestampable behavior
+				if ($this->isModified() && !$this->isColumnModified(sfRatablePeer::UPDATED_AT)) {
+					$this->setUpdatedAt(time());
+				}
+			}
+			if ($ret) {
+				$affectedRows = $this->doSave($con);
+				if ($isInsert) {
+					$this->postInsert($con);
+				} else {
+					$this->postUpdate($con);
+				}
+				$this->postSave($con);
+				// symfony_behaviors behavior
+				foreach (sfMixer::getCallables('BasesfRatable:save:post') as $callable)
+				{
+				  call_user_func($callable, $this, $con, $affectedRows);
+				}
+
+				sfRatablePeer::addInstanceToPool($this);
+			} else {
+				$affectedRows = 0;
+			}
+			$con->commit();
+			return $affectedRows;
+		} catch (PropelException $e) {
+			$con->rollBack();
+			throw $e;
+		}
+	}
+
+	/**
+	 * Performs the work of inserting or updating the row in the database.
+	 *
+	 * If the object is new, it inserts it; otherwise an update is performed.
+	 * All related objects are also updated in this method.
+	 *
+	 * @param      PropelPDO $con
+	 * @return     int The number of rows affected by this insert/update and any referring fk objects' save() operations.
+	 * @throws     PropelException
+	 * @see        save()
+	 */
+	protected function doSave(PropelPDO $con)
+	{
+		$affectedRows = 0; // initialize var to track total num of affected rows
+		if (!$this->alreadyInSave) {
+			$this->alreadyInSave = true;
+
+			if ($this->isNew() ) {
+				$this->modifiedColumns[] = sfRatablePeer::ID;
+			}
+
+			// If this object has been modified, then save it to the database.
+			if ($this->isModified()) {
+				if ($this->isNew()) {
+					$criteria = $this->buildCriteria();
+					if ($criteria->keyContainsValue(sfRatablePeer::ID) ) {
+						throw new PropelException('Cannot insert a value for auto-increment primary key ('.sfRatablePeer::ID.')');
+					}
+
+					$pk = BasePeer::doInsert($criteria, $con);
+					$affectedRows = 1;
+					$this->setId($pk);  //[IMV] update autoincrement primary key
+					$this->setNew(false);
+				} else {
+					$affectedRows = sfRatablePeer::doUpdate($this, $con);
+				}
+
+				$this->resetModified(); // [HL] After being saved an object is no longer 'modified'
+			}
+
+			$this->alreadyInSave = false;
+
+		}
+		return $affectedRows;
+	} // doSave()
+
+	/**
+	 * Array of ValidationFailed objects.
+	 * @var        array ValidationFailed[]
+	 */
+	protected $validationFailures = array();
+
+	/**
+	 * Gets any ValidationFailed objects that resulted from last call to validate().
+	 *
+	 *
+	 * @return     array ValidationFailed[]
+	 * @see        validate()
+	 */
+	public function getValidationFailures()
+	{
+		return $this->validationFailures;
+	}
+
+	/**
+	 * Validates the objects modified field values and all objects related to this table.
+	 *
+	 * If $columns is either a column name or an array of column names
+	 * only those columns are validated.
+	 *
+	 * @param      mixed $columns Column name or an array of column names.
+	 * @return     boolean Whether all columns pass validation.
+	 * @see        doValidate()
+	 * @see        getValidationFailures()
+	 */
+	public function validate($columns = null)
+	{
+		$res = $this->doValidate($columns);
+		if ($res === true) {
+			$this->validationFailures = array();
+			return true;
+		} else {
+			$this->validationFailures = $res;
+			return false;
+		}
+	}
+
+	/**
+	 * This function performs the validation work for complex object models.
+	 *
+	 * In addition to checking the current object, all related objects will
+	 * also be validated.  If all pass then <code>true</code> is returned; otherwise
+	 * an aggreagated array of ValidationFailed objects will be returned.
+	 *
+	 * @param      array $columns Array of column names to validate.
+	 * @return     mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
+	 */
+	protected function doValidate($columns = null)
+	{
+		if (!$this->alreadyInValidation) {
+			$this->alreadyInValidation = true;
+			$retval = null;
+
+			$failureMap = array();
+
+
+			if (($retval = sfRatablePeer::doValidate($this, $columns)) !== true) {
+				$failureMap = array_merge($failureMap, $retval);
+			}
+
+
+
+			$this->alreadyInValidation = false;
+		}
+
+		return (!empty($failureMap) ? $failureMap : true);
+	}
+
+	/**
+	 * Retrieves a field from the object by name passed in as a string.
+	 *
+	 * @param      string $name name
+	 * @param      string $type The type of fieldname the $name is of:
+	 *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+	 *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+	 * @return     mixed Value of field.
+	 */
+	public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
+	{
+		$pos = sfRatablePeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
+		$field = $this->getByPosition($pos);
+		return $field;
+	}
+
+	/**
+	 * Retrieves a field from the object by Position as specified in the xml schema.
+	 * Zero-based.
+	 *
+	 * @param      int $pos position in xml schema
+	 * @return     mixed Value of field at $pos
+	 */
+	public function getByPosition($pos)
+	{
+		switch($pos) {
+			case 0:
+				return $this->getId();
+				break;
+			case 1:
+				return $this->getRatableModel();
+				break;
+			case 2:
+				return $this->getRatableId();
+				break;
+			case 3:
+				return $this->getUserId();
+				break;
+			case 4:
+				return $this->getRating();
+				break;
+			case 5:
+				return $this->getCreatedAt();
+				break;
+			case 6:
+				return $this->getUpdatedAt();
+				break;
+			default:
+				return null;
+				break;
+		} // switch()
+	}
+
+	/**
+	 * Exports the object as an array.
+	 *
+	 * You can specify the key type of the array by passing one of the class
+	 * type constants.
+	 *
+	 * @param     string  $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
+	 *                    BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. 
+	 *                    Defaults to BasePeer::TYPE_PHPNAME.
+	 * @param     boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to TRUE.
+	 *
+	 * @return    array an associative array containing the field names (as keys) and field values
+	 */
+	public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true)
+	{
+		$keys = sfRatablePeer::getFieldNames($keyType);
+		$result = array(
+			$keys[0] => $this->getId(),
+			$keys[1] => $this->getRatableModel(),
+			$keys[2] => $this->getRatableId(),
+			$keys[3] => $this->getUserId(),
+			$keys[4] => $this->getRating(),
+			$keys[5] => $this->getCreatedAt(),
+			$keys[6] => $this->getUpdatedAt(),
+		);
+		return $result;
+	}
+
+	/**
+	 * Sets a field from the object by name passed in as a string.
+	 *
+	 * @param      string $name peer name
+	 * @param      mixed $value field value
+	 * @param      string $type The type of fieldname the $name is of:
+	 *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+	 *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+	 * @return     void
+	 */
+	public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
+	{
+		$pos = sfRatablePeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
+		return $this->setByPosition($pos, $value);
+	}
+
+	/**
+	 * Sets a field from the object by Position as specified in the xml schema.
+	 * Zero-based.
+	 *
+	 * @param      int $pos position in xml schema
+	 * @param      mixed $value field value
+	 * @return     void
+	 */
+	public function setByPosition($pos, $value)
+	{
+		switch($pos) {
+			case 0:
+				$this->setId($value);
+				break;
+			case 1:
+				$this->setRatableModel($value);
+				break;
+			case 2:
+				$this->setRatableId($value);
+				break;
+			case 3:
+				$this->setUserId($value);
+				break;
+			case 4:
+				$this->setRating($value);
+				break;
+			case 5:
+				$this->setCreatedAt($value);
+				break;
+			case 6:
+				$this->setUpdatedAt($value);
+				break;
+		} // switch()
+	}
+
+	/**
+	 * Populates the object using an array.
+	 *
+	 * This is particularly useful when populating an object from one of the
+	 * request arrays (e.g. $_POST).  This method goes through the column
+	 * names, checking to see whether a matching key exists in populated
+	 * array. If so the setByName() method is called for that column.
+	 *
+	 * You can specify the key type of the array by additionally passing one
+	 * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
+	 * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
+	 * The default key type is the column's phpname (e.g. 'AuthorId')
+	 *
+	 * @param      array  $arr     An array to populate the object from.
+	 * @param      string $keyType The type of keys the array uses.
+	 * @return     void
+	 */
+	public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
+	{
+		$keys = sfRatablePeer::getFieldNames($keyType);
+
+		if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
+		if (array_key_exists($keys[1], $arr)) $this->setRatableModel($arr[$keys[1]]);
+		if (array_key_exists($keys[2], $arr)) $this->setRatableId($arr[$keys[2]]);
+		if (array_key_exists($keys[3], $arr)) $this->setUserId($arr[$keys[3]]);
+		if (array_key_exists($keys[4], $arr)) $this->setRating($arr[$keys[4]]);
+		if (array_key_exists($keys[5], $arr)) $this->setCreatedAt($arr[$keys[5]]);
+		if (array_key_exists($keys[6], $arr)) $this->setUpdatedAt($arr[$keys[6]]);
+	}
+
+	/**
+	 * Build a Criteria object containing the values of all modified columns in this object.
+	 *
+	 * @return     Criteria The Criteria object containing all modified values.
+	 */
+	public function buildCriteria()
+	{
+		$criteria = new Criteria(sfRatablePeer::DATABASE_NAME);
+
+		if ($this->isColumnModified(sfRatablePeer::ID)) $criteria->add(sfRatablePeer::ID, $this->id);
+		if ($this->isColumnModified(sfRatablePeer::RATABLE_MODEL)) $criteria->add(sfRatablePeer::RATABLE_MODEL, $this->ratable_model);
+		if ($this->isColumnModified(sfRatablePeer::RATABLE_ID)) $criteria->add(sfRatablePeer::RATABLE_ID, $this->ratable_id);
+		if ($this->isColumnModified(sfRatablePeer::USER_ID)) $criteria->add(sfRatablePeer::USER_ID, $this->user_id);
+		if ($this->isColumnModified(sfRatablePeer::RATING)) $criteria->add(sfRatablePeer::RATING, $this->rating);
+		if ($this->isColumnModified(sfRatablePeer::CREATED_AT)) $criteria->add(sfRatablePeer::CREATED_AT, $this->created_at);
+		if ($this->isColumnModified(sfRatablePeer::UPDATED_AT)) $criteria->add(sfRatablePeer::UPDATED_AT, $this->updated_at);
+
+		return $criteria;
+	}
+
+	/**
+	 * Builds a Criteria object containing the primary key for this object.
+	 *
+	 * Unlike buildCriteria() this method includes the primary key values regardless
+	 * of whether or not they have been modified.
+	 *
+	 * @return     Criteria The Criteria object containing value(s) for primary key(s).
+	 */
+	public function buildPkeyCriteria()
+	{
+		$criteria = new Criteria(sfRatablePeer::DATABASE_NAME);
+		$criteria->add(sfRatablePeer::ID, $this->id);
+
+		return $criteria;
+	}
+
+	/**
+	 * Returns the primary key for this object (row).
+	 * @return     int
+	 */
+	public function getPrimaryKey()
+	{
+		return $this->getId();
+	}
+
+	/**
+	 * Generic method to set the primary key (id column).
+	 *
+	 * @param      int $key Primary key.
+	 * @return     void
+	 */
+	public function setPrimaryKey($key)
+	{
+		$this->setId($key);
+	}
+
+	/**
+	 * Returns true if the primary key for this object is null.
+	 * @return     boolean
+	 */
+	public function isPrimaryKeyNull()
+	{
+		return null === $this->getId();
+	}
+
+	/**
+	 * Sets contents of passed object to values from current object.
+	 *
+	 * If desired, this method can also make copies of all associated (fkey referrers)
+	 * objects.
+	 *
+	 * @param      object $copyObj An object of sfRatable (or compatible) type.
+	 * @param      boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
+	 * @throws     PropelException
+	 */
+	public function copyInto($copyObj, $deepCopy = false)
+	{
+		$copyObj->setRatableModel($this->ratable_model);
+		$copyObj->setRatableId($this->ratable_id);
+		$copyObj->setUserId($this->user_id);
+		$copyObj->setRating($this->rating);
+		$copyObj->setCreatedAt($this->created_at);
+		$copyObj->setUpdatedAt($this->updated_at);
+
+		$copyObj->setNew(true);
+		$copyObj->setId(NULL); // this is a auto-increment column, so set to default value
+	}
+
+	/**
+	 * Makes a copy of this object that will be inserted as a new row in table when saved.
+	 * It creates a new object filling in the simple attributes, but skipping any primary
+	 * keys that are defined for the table.
+	 *
+	 * If desired, this method can also make copies of all associated (fkey referrers)
+	 * objects.
+	 *
+	 * @param      boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
+	 * @return     sfRatable Clone of current object.
+	 * @throws     PropelException
+	 */
+	public function copy($deepCopy = false)
+	{
+		// we use get_class(), because this might be a subclass
+		$clazz = get_class($this);
+		$copyObj = new $clazz();
+		$this->copyInto($copyObj, $deepCopy);
+		return $copyObj;
+	}
+
+	/**
+	 * Returns a peer instance associated with this om.
+	 *
+	 * Since Peer classes are not to have any instance attributes, this method returns the
+	 * same instance for all member of this class. The method could therefore
+	 * be static, but this would prevent one from overriding the behavior.
+	 *
+	 * @return     sfRatablePeer
+	 */
+	public function getPeer()
+	{
+		if (self::$peer === null) {
+			self::$peer = new sfRatablePeer();
+		}
+		return self::$peer;
+	}
+
+	/**
+	 * Clears the current object and sets all attributes to their default values
+	 */
+	public function clear()
+	{
+		$this->id = null;
+		$this->ratable_model = null;
+		$this->ratable_id = null;
+		$this->user_id = null;
+		$this->rating = null;
+		$this->created_at = null;
+		$this->updated_at = null;
+		$this->alreadyInSave = false;
+		$this->alreadyInValidation = false;
+		$this->clearAllReferences();
+		$this->resetModified();
+		$this->setNew(true);
+		$this->setDeleted(false);
+	}
+
+	/**
+	 * Resets all collections of referencing foreign keys.
+	 *
+	 * This method is a user-space workaround for PHP's inability to garbage collect objects
+	 * with circular references.  This is currently necessary when using Propel in certain
+	 * daemon or large-volumne/high-memory operations.
+	 *
+	 * @param      boolean $deep Whether to also clear the references on all associated objects.
+	 */
+	public function clearAllReferences($deep = false)
+	{
+		if ($deep) {
+		} // if ($deep)
+
+	}
+
+	// timestampable behavior
+	
+	/**
+	 * Mark the current object so that the update date doesn't get updated during next save
+	 *
+	 * @return     sfRatable The current object (for fluent API support)
+	 */
+	public function keepUpdateDateUnchanged()
+	{
+		$this->modifiedColumns[] = sfRatablePeer::UPDATED_AT;
+		return $this;
+	}
+
+	/**
+	 * Catches calls to virtual methods
+	 */
+	public function __call($name, $params)
+	{
+		// symfony_behaviors behavior
+		if ($callable = sfMixer::getCallable('BasesfRatable:' . $name))
+		{
+		  array_unshift($params, $this);
+		  return call_user_func_array($callable, $params);
+		}
+
+		if (preg_match('/get(\w+)/', $name, $matches)) {
+			$virtualColumn = $matches[1];
+			if ($this->hasVirtualColumn($virtualColumn)) {
+				return $this->getVirtualColumn($virtualColumn);
+			}
+			// no lcfirst in php<5.3...
+			$virtualColumn[0] = strtolower($virtualColumn[0]);
+			if ($this->hasVirtualColumn($virtualColumn)) {
+				return $this->getVirtualColumn($virtualColumn);
+			}
+		}
+		throw new PropelException('Call to undefined method: ' . $name);
+	}
+
+} // BasesfRatable

lib/model/om/BasesfRatablePeer.php

+<?php
+
+
+/**
+ * Base static class for performing query and update operations on the 'sf_ratable' table.
+ *
+ * 
+ *
+ * This class was autogenerated by Propel 1.5.3-dev on:
+ *
+ * Tue Jul 13 14:46:38 2010
+ *
+ * @package    propel.generator.plugins.sfPropel15RatableBehaviorPlugin.lib.model.om
+ */
+abstract class BasesfRatablePeer {
+
+	/** the default database name for this class */
+	const DATABASE_NAME = 'propel';
+
+	/** the table name for this class */
+	const TABLE_NAME = 'sf_ratable';
+
+	/** the related Propel class for this table */
+	const OM_CLASS = 'sfRatable';
+
+	/** A class that can be returned by this peer. */
+	const CLASS_DEFAULT = 'plugins.sfPropel15RatableBehaviorPlugin.lib.model.sfRatable';
+
+	/** the related TableMap class for this table */
+	const TM_CLASS = 'sfRatableTableMap';
+	
+	/** The total number of columns. */
+	const NUM_COLUMNS = 7;
+
+	/** The number of lazy-loaded columns. */
+	const NUM_LAZY_LOAD_COLUMNS = 0;
+
+	/** the column name for the ID field */
+	const ID = 'sf_ratable.ID';
+
+	/** the column name for the RATABLE_MODEL field */
+	const RATABLE_MODEL = 'sf_ratable.RATABLE_MODEL';
+
+	/** the column name for the RATABLE_ID field */
+	const RATABLE_ID = 'sf_ratable.RATABLE_ID';
+
+	/** the column name for the USER_ID field */
+	const USER_ID = 'sf_ratable.USER_ID';
+
+	/** the column name for the RATING field */
+	const RATING = 'sf_ratable.RATING';
+
+	/** the column name for the CREATED_AT field */
+	const CREATED_AT = 'sf_ratable.CREATED_AT';
+
+	/** the column name for the UPDATED_AT field */
+	const UPDATED_AT = 'sf_ratable.UPDATED_AT';
+
+	/**
+	 * An identiy map to hold any loaded instances of sfRatable objects.
+	 * This must be public so that other peer classes can access this when hydrating from JOIN
+	 * queries.
+	 * @var        array sfRatable[]
+	 */
+	public static $instances = array();
+
+
+	// symfony behavior
+	
+	/**
+	 * Indicates whether the current model includes I18N.
+	 */
+	const IS_I18N = false;
+
+	/**
+	 * holds an array of fieldnames
+	 *
+	 * first dimension keys are the type constants
+	 * e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
+	 */
+	private static $fieldNames = array (
+		BasePeer::TYPE_PHPNAME => array ('Id', 'RatableModel', 'RatableId', 'UserId', 'Rating', 'CreatedAt', 'UpdatedAt', ),
+		BasePeer::TYPE_STUDLYPHPNAME => array ('id', 'ratableModel', 'ratableId', 'userId', 'rating', 'createdAt', 'updatedAt', ),
+		BasePeer::TYPE_COLNAME => array (self::ID, self::RATABLE_MODEL, self::RATABLE_ID, self::USER_ID, self::RATING, self::CREATED_AT, self::UPDATED_AT, ),
+		BasePeer::TYPE_RAW_COLNAME => array ('ID', 'RATABLE_MODEL', 'RATABLE_ID', 'USER_ID', 'RATING', 'CREATED_AT', 'UPDATED_AT', ),
+		BasePeer::TYPE_FIELDNAME => array ('id', 'ratable_model', 'ratable_id', 'user_id', 'rating', 'created_at', 'updated_at', ),
+		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
+	);
+
+	/**
+	 * holds an array of keys for quick access to the fieldnames array
+	 *
+	 * first dimension keys are the type constants
+	 * e.g. self::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0
+	 */
+	private static $fieldKeys = array (
+		BasePeer::TYPE_PHPNAME => array ('Id' => 0, 'RatableModel' => 1, 'RatableId' => 2, 'UserId' => 3, 'Rating' => 4, 'CreatedAt' => 5, 'UpdatedAt' => 6, ),
+		BasePeer::TYPE_STUDLYPHPNAME => array ('id' => 0, 'ratableModel' => 1, 'ratableId' => 2, 'userId' => 3, 'rating' => 4, 'createdAt' => 5, 'updatedAt' => 6, ),
+		BasePeer::TYPE_COLNAME => array (self::ID => 0, self::RATABLE_MODEL => 1, self::RATABLE_ID => 2, self::USER_ID => 3, self::RATING => 4, self::CREATED_AT => 5, self::UPDATED_AT => 6, ),
+		BasePeer::TYPE_RAW_COLNAME => array ('ID' => 0, 'RATABLE_MODEL' => 1, 'RATABLE_ID' => 2, 'USER_ID' => 3, 'RATING' => 4, 'CREATED_AT' => 5, 'UPDATED_AT' => 6, ),
+		BasePeer::TYPE_FIELDNAME => array ('id' => 0, 'ratable_model' => 1, 'ratable_id' => 2, 'user_id' => 3, 'rating' => 4, 'created_at' => 5, 'updated_at' => 6, ),
+		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
+	);
+
+	/**
+	 * Translates a fieldname to another type
+	 *
+	 * @param      string $name field name
+	 * @param      string $fromType One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+	 *                         BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+	 * @param      string $toType   One of the class type constants
+	 * @return     string translated name of the field.
+	 * @throws     PropelException - if the specified name could not be found in the fieldname mappings.
+	 */
+	static public function translateFieldName($name, $fromType, $toType)
+	{
+		$toNames = self::getFieldNames($toType);
+		$key = isset(self::$fieldKeys[$fromType][$name]) ? self::$fieldKeys[$fromType][$name] : null;
+		if ($key === null) {
+			throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(self::$fieldKeys[$fromType], true));
+		}
+		return $toNames[$key];
+	}
+
+	/**
+	 * Returns an array of field names.
+	 *
+	 * @param      string $type The type of fieldnames to return:
+	 *                      One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
+	 *                      BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
+	 * @return     array A list of field names
+	 */
+
+	static public function getFieldNames($type = BasePeer::TYPE_PHPNAME)
+	{
+		if (!array_key_exists($type, self::$fieldNames)) {
+			throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME, BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. ' . $type . ' was given.');
+		}
+		return self::$fieldNames[$type];
+	}
+
+	/**
+	 * Convenience method which changes table.column to alias.column.
+	 *
+	 * Using this method you can maintain SQL abstraction while using column aliases.
+	 * <code>
+	 *		$c->addAlias("alias1", TablePeer::TABLE_NAME);
+	 *		$c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
+	 * </code>
+	 * @param      string $alias The alias for the current table.
+	 * @param      string $column The column name for current table. (i.e. sfRatablePeer::COLUMN_NAME).
+	 * @return     string
+	 */
+	public static function alias($alias, $column)
+	{
+		return str_replace(sfRatablePeer::TABLE_NAME.'.', $alias.'.', $column);
+	}
+
+	/**
+	 * Add all the columns needed to create a new object.
+	 *
+	 * Note: any columns that were marked with lazyLoad="true" in the
+	 * XML schema will not be added to the select list and only loaded
+	 * on demand.
+	 *
+	 * @param      Criteria $criteria object containing the columns to add.
+	 * @param      string   $alias    optional table alias
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function addSelectColumns(Criteria $criteria, $alias = null)
+	{
+		if (null === $alias) {
+			$criteria->addSelectColumn(sfRatablePeer::ID);
+			$criteria->addSelectColumn(sfRatablePeer::RATABLE_MODEL);
+			$criteria->addSelectColumn(sfRatablePeer::RATABLE_ID);
+			$criteria->addSelectColumn(sfRatablePeer::USER_ID);
+			$criteria->addSelectColumn(sfRatablePeer::RATING);
+			$criteria->addSelectColumn(sfRatablePeer::CREATED_AT);
+			$criteria->addSelectColumn(sfRatablePeer::UPDATED_AT);
+		} else {
+			$criteria->addSelectColumn($alias . '.ID');
+			$criteria->addSelectColumn($alias . '.RATABLE_MODEL');
+			$criteria->addSelectColumn($alias . '.RATABLE_ID');
+			$criteria->addSelectColumn($alias . '.USER_ID');
+			$criteria->addSelectColumn($alias . '.RATING');
+			$criteria->addSelectColumn($alias . '.CREATED_AT');
+			$criteria->addSelectColumn($alias . '.UPDATED_AT');
+		}
+	}
+
+	/**
+	 * Returns the number of rows matching criteria.
+	 *
+	 * @param      Criteria $criteria
+	 * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
+	 * @param      PropelPDO $con
+	 * @return     int Number of matching rows.
+	 */
+	public static function doCount(Criteria $criteria, $distinct = false, PropelPDO $con = null)
+	{
+		// we may modify criteria, so copy it first
+		$criteria = clone $criteria;
+
+		// We need to set the primary table name, since in the case that there are no WHERE columns
+		// it will be impossible for the BasePeer::createSelectSql() method to determine which
+		// tables go into the FROM clause.
+		$criteria->setPrimaryTableName(sfRatablePeer::TABLE_NAME);
+
+		if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
+			$criteria->setDistinct();
+		}
+
+		if (!$criteria->hasSelectClause()) {
+			sfRatablePeer::addSelectColumns($criteria);
+		}
+
+		$criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
+		$criteria->setDbName(self::DATABASE_NAME); // Set the correct dbName
+
+		if ($con === null) {
+			$con = Propel::getConnection(sfRatablePeer::DATABASE_NAME, Propel::CONNECTION_READ);
+		}
+		// symfony_behaviors behavior
+		foreach (sfMixer::getCallables(self::getMixerPreSelectHook(__FUNCTION__)) as $sf_hook)
+		{
+		  call_user_func($sf_hook, 'BasesfRatablePeer', $criteria, $con);
+		}
+
+		// BasePeer returns a PDOStatement
+		$stmt = BasePeer::doCount($criteria, $con);
+
+		if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
+			$count = (int) $row[0];
+		} else {
+			$count = 0; // no rows returned; we infer that means 0 matches.
+		}
+		$stmt->closeCursor();
+		return $count;
+	}
+	/**
+	 * Method to select one object from the DB.
+	 *
+	 * @param      Criteria $criteria object used to create the SELECT statement.
+	 * @param      PropelPDO $con
+	 * @return     sfRatable
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelectOne(Criteria $criteria, PropelPDO $con = null)
+	{
+		$critcopy = clone $criteria;
+		$critcopy->setLimit(1);
+		$objects = sfRatablePeer::doSelect($critcopy, $con);
+		if ($objects) {
+			return $objects[0];
+		}
+		return null;
+	}
+	/**
+	 * Method to do selects.
+	 *
+	 * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+	 * @param      PropelPDO $con
+	 * @return     array Array of selected Objects
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function doSelect(Criteria $criteria, PropelPDO $con = null)
+	{
+		return sfRatablePeer::populateObjects(sfRatablePeer::doSelectStmt($criteria, $con));
+	}
+	/**
+	 * Prepares the Criteria object and uses the parent doSelect() method to execute a PDOStatement.
+	 *
+	 * Use this method directly if you want to work with an executed statement durirectly (for example
+	 * to perform your own object hydration).
+	 *
+	 * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
+	 * @param      PropelPDO $con The connection to use
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 * @return     PDOStatement The executed PDOStatement object.
+	 * @see        BasePeer::doSelect()
+	 */
+	public static function doSelectStmt(Criteria $criteria, PropelPDO $con = null)
+	{
+		if ($con === null) {
+			$con = Propel::getConnection(sfRatablePeer::DATABASE_NAME, Propel::CONNECTION_READ);
+		}
+
+		if (!$criteria->hasSelectClause()) {
+			$criteria = clone $criteria;
+			sfRatablePeer::addSelectColumns($criteria);
+		}
+
+		// Set the correct dbName
+		$criteria->setDbName(self::DATABASE_NAME);
+		// symfony_behaviors behavior
+		foreach (sfMixer::getCallables(self::getMixerPreSelectHook(__FUNCTION__)) as $sf_hook)
+		{
+		  call_user_func($sf_hook, 'BasesfRatablePeer', $criteria, $con);
+		}
+
+
+		// BasePeer returns a PDOStatement
+		return BasePeer::doSelect($criteria, $con);
+	}
+	/**
+	 * Adds an object to the instance pool.
+	 *
+	 * Propel keeps cached copies of objects in an instance pool when they are retrieved
+	 * from the database.  In some cases -- especially when you override doSelect*()
+	 * methods in your stub classes -- you may need to explicitly add objects
+	 * to the cache in order to ensure that the same objects are always returned by doSelect*()
+	 * and retrieveByPK*() calls.
+	 *
+	 * @param      sfRatable $value A sfRatable object.
+	 * @param      string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
+	 */
+	public static function addInstanceToPool(sfRatable $obj, $key = null)
+	{
+		if (Propel::isInstancePoolingEnabled()) {
+			if ($key === null) {
+				$key = (string) $obj->getId();
+			} // if key === null
+			self::$instances[$key] = $obj;
+		}
+	}
+
+	/**
+	 * Removes an object from the instance pool.
+	 *
+	 * Propel keeps cached copies of objects in an instance pool when they are retrieved
+	 * from the database.  In some cases -- especially when you override doDelete
+	 * methods in your stub classes -- you may need to explicitly remove objects
+	 * from the cache in order to prevent returning objects that no longer exist.
+	 *
+	 * @param      mixed $value A sfRatable object or a primary key value.
+	 */
+	public static function removeInstanceFromPool($value)
+	{
+		if (Propel::isInstancePoolingEnabled() && $value !== null) {
+			if (is_object($value) && $value instanceof sfRatable) {
+				$key = (string) $value->getId();
+			} elseif (is_scalar($value)) {
+				// assume we've been passed a primary key
+				$key = (string) $value;
+			} else {
+				$e = new PropelException("Invalid value passed to removeInstanceFromPool().  Expected primary key or sfRatable object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value,true)));
+				throw $e;
+			}
+
+			unset(self::$instances[$key]);
+		}
+	} // removeInstanceFromPool()
+
+	/**
+	 * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
+	 *
+	 * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+	 * a multi-column primary key, a serialize()d version of the primary key will be returned.
+	 *
+	 * @param      string $key The key (@see getPrimaryKeyHash()) for this instance.
+	 * @return     sfRatable Found object or NULL if 1) no instance exists for specified key or 2) instance pooling has been disabled.
+	 * @see        getPrimaryKeyHash()
+	 */
+	public static function getInstanceFromPool($key)
+	{
+		if (Propel::isInstancePoolingEnabled()) {
+			if (isset(self::$instances[$key])) {
+				return self::$instances[$key];
+			}
+		}
+		return null; // just to be explicit
+	}
+	
+	/**
+	 * Clear the instance pool.
+	 *
+	 * @return     void
+	 */
+	public static function clearInstancePool()
+	{
+		self::$instances = array();
+	}
+	
+	/**
+	 * Method to invalidate the instance pool of all tables related to sf_ratable
+	 * by a foreign key with ON DELETE CASCADE
+	 */
+	public static function clearRelatedInstancePool()
+	{
+	}
+
+	/**
+	 * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
+	 *
+	 * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+	 * a multi-column primary key, a serialize()d version of the primary key will be returned.
+	 *
+	 * @param      array $row PropelPDO resultset row.
+	 * @param      int $startcol The 0-based offset for reading from the resultset row.
+	 * @return     string A string version of PK or NULL if the components of primary key in result array are all null.
+	 */
+	public static function getPrimaryKeyHashFromRow($row, $startcol = 0)
+	{
+		// If the PK cannot be derived from the row, return NULL.
+		if ($row[$startcol] === null) {
+			return null;
+		}
+		return (string) $row[$startcol];
+	}
+
+	/**
+	 * Retrieves the primary key from the DB resultset row 
+	 * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
+	 * a multi-column primary key, an array of the primary key columns will be returned.
+	 *
+	 * @param      array $row PropelPDO resultset row.
+	 * @param      int $startcol The 0-based offset for reading from the resultset row.
+	 * @return     mixed The primary key of the row
+	 */
+	public static function getPrimaryKeyFromRow($row, $startcol = 0)
+	{
+		return (int) $row[$startcol];
+	}
+	
+	/**
+	 * The returned array will contain objects of the default type or
+	 * objects that inherit from the default.
+	 *
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function populateObjects(PDOStatement $stmt)
+	{
+		$results = array();
+	
+		// set the class once to avoid overhead in the loop
+		$cls = sfRatablePeer::getOMClass(false);
+		// populate the object(s)
+		while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
+			$key = sfRatablePeer::getPrimaryKeyHashFromRow($row, 0);
+			if (null !== ($obj = sfRatablePeer::getInstanceFromPool($key))) {
+				// We no longer rehydrate the object, since this can cause data loss.
+				// See http://www.propelorm.org/ticket/509
+				// $obj->hydrate($row, 0, true); // rehydrate
+				$results[] = $obj;
+			} else {
+				$obj = new $cls();
+				$obj->hydrate($row);
+				$results[] = $obj;
+				sfRatablePeer::addInstanceToPool($obj, $key);
+			} // if key exists
+		}
+		$stmt->closeCursor();
+		return $results;
+	}
+	/**
+	 * Populates an object of the default type or an object that inherit from the default.
+	 *
+	 * @param      array $row PropelPDO resultset row.
+	 * @param      int $startcol The 0-based offset for reading from the resultset row.
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 * @return     array (sfRatable object, last column rank)
+	 */
+	public static function populateObject($row, $startcol = 0)
+	{
+		$key = sfRatablePeer::getPrimaryKeyHashFromRow($row, $startcol);
+		if (null !== ($obj = sfRatablePeer::getInstanceFromPool($key))) {
+			// We no longer rehydrate the object, since this can cause data loss.
+			// See http://www.propelorm.org/ticket/509
+			// $obj->hydrate($row, $startcol, true); // rehydrate
+			$col = $startcol + sfRatablePeer::NUM_COLUMNS;
+		} else {
+			$cls = sfRatablePeer::OM_CLASS;
+			$obj = new $cls();
+			$col = $obj->hydrate($row, $startcol);
+			sfRatablePeer::addInstanceToPool($obj, $key);
+		}
+		return array($obj, $col);
+	}
+	/**
+	 * Returns the TableMap related to this peer.
+	 * This method is not needed for general use but a specific application could have a need.
+	 * @return     TableMap
+	 * @throws     PropelException Any exceptions caught during processing will be
+	 *		 rethrown wrapped into a PropelException.
+	 */
+	public static function getTableMap()
+	{
+		return Propel::getDatabaseMap(self::DATABASE_NAME)->getTable(self::TABLE_NAME);
+	}
+
+	/**
+	 * Add a TableMap instance to the database for this peer class.
+	 */
+	public static function buildTableMap()
+	{
+	  $dbMap = Propel::getDatabaseMap(BasesfRatablePeer::DATABASE_NAME);
+	  if (!$dbMap->hasTable(BasesfRatablePeer::TABLE_NAME))
+	  {
+	    $dbMap->addTableObject(new sfRatableTableMap());
+	  }
+	}
+
+	/**
+	 * The class that the Peer will make instances of.
+	 *
+	 * If $withPrefix is true, the returned path