php scripts/create_model.php –-table-name customers –-enable-casting yes

public function getProperty();
public function setProperty($valueOfProperty);

protected function initialize(){
     $this->setTransient("user_code");
}

CREATE TABLE `country` (
  `code` int(11) NOT NULL,
  `name` varchar(20) default NULL,
  PRIMARY KEY  (`code`)
);

CREATE TABLE `city` (
  `code` int(11) NOT NULL,
  `country_code` int(11) default NULL,
  `name` varchar(80) default NULL,
  PRIMARY KEY  (`code`)
);

<?php

class City extends ActiveRecord { 

     protected function initialize(){
          $this->belongsTo("country_code", "country", "code");
     }

}

$city = EntityManager::getEntityInstance("City");
$city->findByName("Bogotá");
$country = $city->getCountry()
echo $country->getNombre(); // => Colombia

CREATE TABLE `customer` (
  `identification_type` char(3) NOT NULL default '',
  `number` varchar(40) NOT NULL default '',
  `nombre` varchar(120) default NULL,
  `status` char(1) default NULL,
  PRIMARY KEY  (`identification_type`,`number`)
);

CREATE TABLE `flights` (
  `flight_number` varchar(12) NOT NULL default '',
  `identification_type` char(3) default NULL,
  `number` varchar(40) default NULL,
  `flight_date` date default NULL,
  `initial_hour` time default NULL,
  `final_hour` time default NULL,
  PRIMARY KEY  (`flight_number`)
);

<?php

class Flights extends ActiveRecord { 

     protected function initialize(){
          $this->belongsTo(array("identification_type", "number"), "customer");
     }

}

$flight = $this->Flights->findByDate("2008-11-01");
$customer = $flight->getCustomer();

//Grabar todas las operaciones SQL internas a un archivo en logs/customersDebug.txt
$this->Employees->setLogger("customersDebug.txt");

$logger = new Logger('Compressed', 'log.employees.txt.gz');
$logger->setPath("/usr/local/log/");
$this->Employees->setLogger($logger);

$myLog = new MyUserLog();
$this->Employees->setLogger($myLog);

//Obtener los empleados con una condición en un subselect
$empoyees = $this->Employees->findBySql("SELECT employees.* FROM employees WHERE id NOT IN (SELECT employees_id FROM historical_data WHERE period = '2005-02'");

//Obtener el primer empleado que se almacenó en la entidad
$employee = $this->Employees->findFirst();

//Obtener el primer usuario cuyo login sea 'j.smith'
$user = $this->Users->findFirst("login = 'j.smith'");

//Obtener el ultimo producto cuyo precio sea menor a 100 y este activo
$user = $this->Products->findFirst("price < 100 AND status = 'Active'", "order: price DESC");

//Obtener todos los registros de una entidad
$employees = $this->Employees->find();

//Obtener todos los registros que cumplan con una condición
$employees = $this->Employees->find("status = 'Active'");

//Obtener todos los registros que cumplan una condición y aplicándoles un ordenamiento
$employees = $this->Employees->find("status = 'Active'", "order: name desc");

//Obtener todos los registros y aplicarles un ordenamiento
$employees = $this->Employees->find("order: name");

//Obtener los 20 primeros registros que cumplan con unas condiciones
$employees = $this->Employees->find("agreement_date >= '2008-12-31' AND status='Active'", "limit: 20");

<?php

class OrdersController extends ApplicationController {

     public function increaseQuantityAction(){
          try {
               $transaction = new ActiveRecordTransaction(true);     
               $this->Products->setTransaction($transaction); 
               foreach($this->Products->findForUpdate("quantity<100") as  $product){ 
                    $product->setQuantity($product->getMinStock()*2);
                    if($product->save()==false){
                         $transaction->rollback();
                    }
               }
          }
          catch(TransactionFailed $e) {
               Flash::error($e->getMessage());
          }
     }
}

//Cuantos productos hay?
$this->Products->count();

//Cuantos productos tienen categoria 1
$this->Products->count("categories_id = 1");

//Contar productos por categoria
foreach($this->Products->count("group: categories_id") as $result){
     echo $result->categories_id." ".$result->rowcount;
}

// Contar productos por categoria, mostrar aquellas categorias que tienen mas de // 10 productos
$resultset =$this->Products->count("group: categories_id", "having: rowcount>10");
foreach($resultset as $result){
     echo $result->categories_id." ".$result->rowcount;
}

//En promedio, cual es el precio de un producto
$this->Products->average("price");

//En promedio, cual es el precio de un producto activo
$this->Products->average("price", "conditions: status='Active'");

//Promedio de precios por categoria
$averages = $this->Products->average("price", "group: categories_id");
foreach($averages as $result){
     echo $result->categories_id." ".$result->average."\n";
}

//Cuanto suman los impuestos en las ordenes de compra?
$this->Orders->sum("taxes");

//Cuanto suman los impuestos del año 2007?
$this->Orders->sum("taxes", "conditions: year = '2007'");

//Cuanto suman las cantidades en las ordenes de compra por cada cliente
$summatories = $this->Orders->sum("quantity", "group: customers_id");
foreach($summatories as $result){
     echo $result->categories_id." ".$result->summatory."\n";
}

//Cuanto suman las cantidades en las ordenes de compra por cada cliente, cuya //cantidad sea superior a 100 unidades
$summatories = $this->Orders->sum("quantity", "group: customers_id", "having: summatory>100");
foreach($summatories as $result){
     echo $result->categories_id." ".$result->summatory."\n";
}

//Quien es el empleado más antiguo?
$this->Employees->maximum("contract_date", "conditions: status='Active'");

//Quien es el empleado más nuevo?
$this->Employees->minimum("contract_date", "conditions: status='Active'");

<?php

$product = new Products();
$product->setName('Potattos');
$product->setType('Food');
if($product->save()==false){
     foreach($product->getMessages() as $message){
          Flash::error($message->getMessage());
     }
}

//Relación de un campo a otro por convención
$this->hasOne("tabla_id");

//Relación de un campo a otro 
$this->hasOne("campo", "tabla_referenciada", "campo_referenciado");

//Relación de varios campos a varios campos
$this->hasOne(
     array("campo1", "campo2"), 
     "tabla_referenciada", 
     array("campo_referenciado1", "campo_referenciado2")
);

//Relación de un campo a otro por convención
$this->belongsTo("tabla_id");

//Relación de un campo a otro 
$this->belongsTo("campo", "tabla_referenciada", "campo_referenciado");

//Relación de varios campos a varios campos
$this->belongsTo(
     array("campo1", "campo2"), 
     "tabla_referenciada", 
     array("campo_referenciado1", "campo_referenciado2")
);

//Relación de un campo a otro por convención
$this->hasMany("tabla_id");

//Relación de un campo a otro 
$this->hasMany("campo", "tabla_referenciada", "campo_referenciado");

//Relación de varios campos a varios campos
$this->hasMany(
     array("campo1", "campo2), 
     "tabla_referenciada", 
     array("campo_referenciado1", "campo_referenciado2")
);

<?php

class Invoices extends ActiveRecord {

     public function initialize(){
          $this->setIdGenerator("Hilo", "code", array(
               "table" => "invoces_data",
               "column" => "consecutive",
               "max_lo" => 100
          ));
     }

}

4cfce7c2-6089-102c-91cf-d8dbbe268425

<?php

class Media extends ActiveRecord {

     public function initialize(){
          $this->setIdGenerator("Uuid", "id");
     }

}

<?php

class Media extends ActiveRecord {

     public function initialize(){
          $this->setIdGenerator("Uniqid", "id");
     }

}

<?php

class Orders extends ActiveRecord {

     public function sequenceName(){
          return "ORDERS_SEQ";
     }

     public function initialize(){
          $this->setIdGenerator("Native", "id");
     }

}

<?php

class Orders extends ActiveRecord {

     public function initialize(){
          $this->setIdGenerator("Sequence", "id", array(
               "name" => "ORDERS_ID"
          ));
     }

}

<?php

class Orders extends ActiveRecord {

     public function sequenceName(){
          return "ORDERS_ID_SEQ";
     }


     public function initialize(){
          $this->setIdGenerator("Sequence", "id");
     }

}

//Recorrerlo con Foreach
foreach($this->Products->find() as $product){
     echo $product->getId(), "\n";
}

//Recorrerlo con While
$resultSet = $this->Products->find();
while($resultSet->valid()){
     $product = $resultSet->current();
     echo $product->getId(), "\n";
}

$resultSet = $this->Products->find();

//Obtener el primer registro
echo $resultSet->getFirst()->id, "\n";

//Obtener el segundo registro
echo $resultSet->offsetGet(1)->id, "\n";

//Obtener el último
echo $resultSet->getLast()->id, "\n";

<?php

$customer = new Customer();
$customer->setName("Steve Conrad");
$customer->setEmail("s.conrad@mail.com");
if($customer->save()==false){
     foreach($customer->getMessages() as $message){
          Flash::error($message->getMessage());
     }
}

<?php

interface TransactionManagerInterface {

     public function getUserTransaction($definition=null);
     public function commit();
     public function rollback();
     public function initializeManager();
     public function rollbackPendent();
     public static function notifyRollback();
     public static function notifyCommit();

}

<?php

class AccountsController extends ApplicationController {

     public function createCustomerDataAction(){

          try {
               $definition = new TransactionDefinition();
               $definition-> setIsolationLevel(TransactionDefinition::ISOLATION_SERIALIZABLE);
               $definition->setPropagation(false);
               $definition->setReadOnly(false);
               $definition->setTimeout(0);

               $transaction = TransactionManager::getUserTransaction($definition);

               $customer = new Customer();
               $customer->setTransaction($transaction);
               $customer->setName("John Smith");
               $customer->setStatus("Active");
               if($customer->save()){
                    $this->routeToAction("action: createAccountData");
               } else {
                    $transaction->rollback();
               }
          }
          catch(TransactionFailed $e){
               Flash::error($e->getMessage());
          }
     }

     public function createCustomerDataAction($clientId){

          $clientId = $this->filter($clientId, "int");

          try {
               $transaction = TransactionManager::getUserTransaction($definition);
               $this->Account->setTransaction($transaction);

               $accounts = $this->Account->findWithSharedLock("client_id='$clientId'");
               foreach($accounts as $account){
                    if($account->getStatus()=='Inactive'){
                         $account->setBalance(0);
                         $account->setStatus('Active');
                         if($account->save()==false){
                              foreach($account->getMessages() as $message){
                                   Flash::error($message->getMessage());
                              }
                              $transaction->rollback();
                         }
                    }
               }
               if($transaction->commit()==true){
                    Flash::success("Se creó correctamente el cliente");
               }
          }
          catch(TransactionFailed $e){
               Flash::error($e->getMessage());
          }

     }

}

$invoice = new Invoice();
$db = $invoice->getConnection();
$db->begin();
$invoice->find(124);
$invoice->setStatus("Cancelled");
$invoice->save();
$db->commit();

<?php

try {
     $transaction = new ActiveRecordTransaction(true);
     foreach($Accounts->find("status = 'P'") as $accountItem){
          $accountItem->setTransaction($transaction);
          $accountItem->setStatus("A");
          if($accountItem->save()==false){
               foreach($accountItem->getMessages() as $message){
                    Flash::error($message->getMessage());
               }
               $transaction->rollback();
          }
     }

     $accounts = $Accounts->find("status='A' AND customer_id='$customerId'");
     foreach($accounts as $accountItem){
          $accountItem->setTransaction($transaction);
          $balance = $accountItem->getBalance();
          $accountItem->setBalance($balance-$manageDiscount);
          if($accountItem->save()==false){
               foreach($accountItem->getMessages() as $message){
                    Flash::error($message->getMessage());
               }
               $transaction->rollback();
          }
     }

     $transaction->commit();

}
catch(TransactionFailed $e){
     Flash::error($e->getMessage());
}

<?php

try {
     $transaction = new ActiveRecordTransaction(true);
     $Accounts->setTransaction($transaction);
     foreach($Accounts->find("status = 'P'") as $accountItem){
          $accountItem->setStatus("A");
          if($accountItem->save()==false){
               foreach($accountItem->getMessages() as $message){
                    Flash::error($message->getMessage());
               }
               $transaction->rollback();
          }
     }

     $accounts = $Accounts->find("status='A' AND customer_id='$customerId'");
     foreach($accounts as $accountItem){
          $balance = $accountItem->getBalance();
          $accountItem->setBalance($balance-$manageDiscount);
          if($accountItem->save()==false){
               foreach($accountItem->getMessages() as $message){
                    Flash::error($message->getMessage());
               }
               $transaction->rollback();
          }
     }

     $transaction->commit();

}
catch(TransactionFailed $e){
     Flash::error($e->getMessage());
}

<?php

class OrdersController extends ApplicationController {

     public function increaseQuantityAction(){
          try {
               $transaction = new ActiveRecordTransaction(true);
               $this->Products->setTransaction($transaction); 
               $products = $this->Products->findForUpdate("quantity<100");
               foreach($products as $product){
                    $product->setQuantity($product->getMinStock()*2);
                    if($product->save()==false){
                         $transaction->rollback();
                    }
               }
          }
          catch(DbLockAdquisitionException $e){
               Flash::error("No se pudo obtener el bloqueo requerido");
          }
          catch(TransactionFailed $e){
               Flash::error($e->getMessage());
          }
     }
}

<?php

class Customers extends ActiveRecord {

     protected $id;
     protected $name;
     protected $e_mail;
     protected $status;

     protected function setId($id){
          $this->id = $id;
     }

     protected function setName($name){
          $this->name = $name;
     }

     protected function setEMail($e_mail){
          $this->e_mail = $e_mail;
     }

     protected function setStatus($status){
          $this->status = $status;
     }

     protected function validation(){
          $this->validate("Length", array(
               "field" => "name",
               "minimum" => 10, 
               "maximum" => 50
          ));
          $this->validate("Email", "e_mail");
          $this->validate("InclusionIn", array(
               "field" => "status", 
               "domain" => array("A", "I"), 
               "required" => false
          ));

          if($this->validationHasFailed()==true){
               return false;
          }
     }
}

protected function validation(){     
     $this->validate("Numericality", array(
          "field" => "precio_venta", 
          "required" => false
));
     if($this->validationHasFailed()==true){
          return false;
     }
}

protected function validation(){          
     $this->validate("Uniqueness", array(
          "field" => array("invoice_number", "invoice_preffix")
     );
     if($this->validationHasFailed()==true){
          return false;
     }
}

<?php

$customer = new Customer();
$customer->setName("Carl Johnson");
$customer->setEmail("c.johnson@mail.com");
$customer->setContractDate("2009-02-01");
if($customer->save()==false){
     foreach($customer->getMessages() as $message){
          Flash::error($message->getMessage());
     }
}

<?php

$customer = new Customer();
$customer->setName("Carl Johnson");
$customer->setEmail("c.johnson@mail.com");
$customer->setContractDate("2009-02-01");
if($customer->save()==false){
     foreach($customer->getMessages() as $message){
          if($message->getType()=='Email'){
               Flash::warning($message->getMessage());
          } else {
               Flash::error($message->getMessage());
          }
     }
}

<?php

$customer = new Customer();
$customer->setName("Carl Johnson");
$customer->setEmail("c.johnson@mail.com");
$customer->setContractDate($contractDate);
if($customer->save()==false){
     foreach($customer->getMessages() as $message){
          if($message->getField()=='contractDate'){
               Flash::warning("La fecha de contrato no ha sido establecida");
          } else {
               Flash::error($message->getMessage());
          }
     }
}

interface ActiveRecordValidatorInterface {

     public function __construct($record, $field, $value, $options = array());
     public function checkOptions();
     public function getMessages();
     public function validate();

}

<?php

class IdentificationValidator extends ActiveRecordValidator
     implements ActiveRecordValidatorInterface {

     public function checkOptions(){
          if($this->isSetOption('type')==false){
               throw new ActiveRecordException("Debe indicar el tipo de numero de identificación para IdentificationValidator");
          }
          if(!in_array($this->getOption('type'), array('any', 'company', 'people'))){
               throw new ActiveRecordException("El tipo de número de identificación no es valido, para IdentificationValidator");
          }
     }

     public function validate(){
          $number = $this->getValue();
          $type = $this->getOption('type');
          $valid = true;
          if($type=='any'||$type=='company'){
               if(substr($number, 0, 3)=='ABZ'){
                    $valid = false;
               }
          }
          if($type=='any'||$type=='people'){
               if(substr($number, 0, 3)!='XYZ'){
                    $valid = false;
               }
          }
          if(strlen($number)!=20){
               $valid = false;
          }
          if(!$valid){
               $this->appendMessage("El valor del campo '".$this->getFieldName()."' debe ser una identificación válida");
               return false;
          } else {
               return true;
          }
     }
}

protected function beforeValidationOnCreate(){          
     $this->validate("Identification", array(
          "field" => "number_iden", 
          "type" => "any"
     ));
     if($this->validationHasFailed()==true){
          return false;
     }
}

<?php

class Products extends ActiveRecord {

     protected function beforeSave(){
          if($this->quantity<0){
               Flash::error("La cantidad no puede ser negativa");
               return false;
          }
     }

}

<?php

class Products extends ActiveRecord {

     protected $beforeSave = "myCustomEvent"

     protected function myCustomEvent(){
          if($this->quantity<0){
               Flash::error("La cantidad no puede ser negativa");
               return false;
          }
     }

}

<?php

class Products extends ActiveRecord {

     protected $beforeSave = array("myFirstEvent", "mySecondEvent");

     protected function myFirstEvent(){
          if($this->quantity<0){
               Flash::error("La cantidad no puede ser negativa");
               return false;
          }
     }

     protected function mySecondEvent(){
          if($this->quantity>100){
               Flash::error("La cantidad no puede ser mayor a 100");
               return false;
          }
     }


}

<?php

class Products extends ActiveRecord {

     protected $beforeSave;

     protected function beforeValidation(){
          if($this->category=="Food"){
               $this->beforeSave = "checkFoodQuantity";
          } else {
               $this->beforeSave = "checkOtherQuantity";
          }
     }

     protected function checkFoodQuantity(){
          if($this->quantity>100){
               Flash::error("La cantidad de alimentos no puede ser mayor a 100");
               return false;
          }
     }

     protected function checkOtherQuantity(){
          if($this->quantity>50){
               Flash::error("La cantidad no puede ser mayor a 50");
               return false;
          }
     }

}

<?php

class Products extends ActiveRecord {

     protected function onValidationFails(){
          if($this->operationWasCreate()==true){
               Flash::error("La inserción falló");
          }
          if($this->operationWasUpdate()==true){
               Flash::error("La actualización falló");
          }
          foreach($this->getMessages() as $message()){
               Flash::error($message->getMessage());
          }
     }


}

<?php

class Products extends ActiveRecord {

     protected function initialize(){
          $this->addForeignKey("categories_id");
     }

}

<?php

class Employees extends ActiveRecord {

     protected function initialize(){

          //Un campo a un campo
          $this->addForeignKey("code_cat", "categories", "code");

          //Varios campos a varios campos
          $this->addForeignKey(
               array("country_born", "city_born"), 
               "cities", 
               array("country_code", "city_code")
          );

     }

}

<?php

class Employees extends ActiveRecord {

     protected function initialize(){

          $this->addForeignKey("office_id", "office", "id", array(
               "message" => "La oficina %s no existe",
               "on_delete" => ActiveRecord::ACTION_CASCADE,
               "on_update" => ActiveRecord::ACTION_RESTRICT
          ));

     }

}

<?php

class ProductStadistics extends TemporaryActiveRecord {

     protected $id;
     protected $product_id;
     protected $cantidad;

     public function getId(){
          return $this->id;
     }

     public function getProductId(){
          return $this->product_id;
     }

     public function getCantidad(){
          return $this->cantidad;
     }

     public function setId($id){
          $this->id = $id;
     }

     public function setProductId($product_id){
          $this->product_id = $product_id;
     }

     public function setCantidad($cantidad){
          $this->cantidad = $cantidad;
     }

     protected function _tableDefinition(){
          return array(
               "attributes" => array(
                    "id" => array(
                         "type" => DbBase::TYPE_INTEGER,
                         "notNull" => true,
                         "primary" => true,
                         "auto" => true
                    ),
                    "product_id" => array(
                         "type" => DbBase::TYPE_INTEGER,
                         "notNull" => true
                    ),
                    "cantidad" => array(
                         "type" => DbBase::TYPE_VARCHAR,
                         "notNull" => true,
                         "size" => 10
                    )
               ),
               "indexes" => array("product_id")
          );
     }

     protected function initialize(){
          $this->belongsTo("product");
     }

}

try {
     $transaction = TransactionManager::getUserTransaction();     
     $this->Movement->setTransaction($transaction);
     $this->Cart->setTransaction($transaction);
     $conditions = "sellDate = '".Date::getCurrentDate()."'";
     foreach($this->Movement->find($conditions) as $movement){
          $productStadistic = new ProductStatistics();
          $productStadistic->setTransaction($transaction);
          $productStadistic->setProductId($movement->getProductId());
          $productStadistic->setCantidad($movement->getQuantity());
          if($productStadistic->save()==false){
               foreach($productStadistic->getMessages() as $message){
                    Flash::error($message->getMessage());
               }
               $transaction->rollback();
          }
     }
     $transaction->commit();
     $productStadistic = $this->ProductStadistics->findFirst();

     echo "La cantidad total de productos es: ";
     echo $productStadistic->sum("cantidad")."<br>";

     echo "La cantidad minima es: ";
     echo $productStadistic->minimum("cantidad")."<br>";

     echo "La cantidad máxima es: ";
     echo $productStadistic->maximum("cantidad")."<br>";

     echo "El promedio de cantidad es: ";
     echo $productStadistic->average("cantidad")."<br>";

}
catch(TransactionFailed $e){
     Flash::error($e->getMessage());
}

CREATE TABLE `products_categories` (
  `id` int(18) NOT NULL,
  `name` varchar(70) default NULL,
  PRIMARY KEY  (`id`)
);

CREATE TABLE `products` (
  `id` int(18) NOT NULL,
  `name` varchar(100) default NULL,
  `products_categories_id` int(11) NOT NULL,
  `quantity` int(11) NOT NULL,
  `price` decimal(16,2) NOT NULL,
  PRIMARY KEY  (`id`)
);

CREATE TABLE `customers` (
  `id` int(18) NOT NULL,
  `name` varchar(20) default NULL,
  PRIMARY KEY  (`id`)
);

CREATE TABLE `invoices` (
  `id` int(18) NOT NULL,
  `customers_id` int(18) NOT NULL,
  `sell_date` date NOT NULL,
  PRIMARY KEY  (`id`)
);

CREATE TABLE `invoices_lines` (
  `id` int(18) NOT NULL,
  `invoices_id` int(18) NOT NULL,
  `products_id` int(18) NOT NULL,
 `quantity` int(11) NOT NULL,
 `price` decimal(16,2) NOT NULL,
 `taxes` decimal(16,2) NOT NULL,
  PRIMARY KEY  (`id`)
);

<?php

// Modelo de Categorias de Productos
class ProductsCategories extends ActiveRecord {
     
     public function initialize(){
          // Relación 1-n con productos
          $this->hasMany("products");
     }
     
}

// Modelo de Productos
class Products extends ActiveRecord {
     
     public function initialize(){
          // Relacion 1-1 inversa con categorias de productos
          $this->belongsTo("products_categories");
          // Relacion 1-n con lineas de facturas
          $this->hasMany("invoices_lines");
     }
     
}

// Modelo de Clientes
class Customers extends ActiveRecord {
     
     public function initialize(){
          // Relacion 1-n con facturas
          $this->hasMany("invoices");
     }
     
}

// Modelo de Facturas
class Invoices extends ActiveRecord {
     
     public function initialize(){
          // Relacion 1-1 inversa con clientes
          $this->belongsTo("customers");          
     }
     
}

// Modelo de Detalle de Facturas
class InvoicesLines extends ActiveRecord {
     
     public function initialize(){
          // Relacion 1-1 inversa con clientes
          $this->belongsTo("invoices");          
          // Relacion 1-1 inversa con productos
          $this->belongsTo("products");
     }
     
}

//Listar los productos vendidos, su cantidad y la fecha en que se vendieron

$query = new ActiveRecordJoin(array(
     "entities" => array("Invoices", "Products", "InvoicesLines"),
     "fields" => array(
          "{#Products}.name", 
          "{#Invoices}.sell_date", 
          "{#InvoicesLines}.quantity"
     )
));

//Mediante getters
foreach($query->getResultSet() as $result){
     echo $result->getName()." ".
     $result->getSellDate()." ".
     $result->getQuantity()."\n";
}

//Mediante atributos públicos
foreach($query->getResultSet() as $result){
     echo $result->name." ".$result->sell_date." ".$result->quantity."\n";
}

SELECT products.name, invoices.sell_date, invoices_lines.quantity FROM invoices, products, invoices_lines WHERE products.id = invoices_lines.products_id AND invoices.id = invoices_lines.invoices_id ORDER BY 1

//Cuantos productos se han vendido por cada producto
$query = new ActiveRecordJoin(array(
     "entities" => array("Invoices", "Products", "InvoicesLines"),
     "groupFields" => array("{#Products}.name"),
     "sumatory" => array("{#InvoicesLines}.quantity")
));

// Cuantos productos se han vendido por cada producto, cuya cantidad vendida sea // mayor a 150
$query = new ActiveRecordJoin(array(
     "entities" => array("Invoices", "Products", "InvoicesLines"),
     "groupFields" => array("{#Products}.name"),
     "sumatory" => array("{#InvoicesLines}.quantity"),
     "having" => "quantity>10"
));

//En promedio cuál ha sido el precio del producto durante el mes de octubre
$query = new ActiveRecordJoin(array(
     "entities" => array("Invoices", "Products", "InvoicesLines"),
     "groupFields" => array("{#Products}.name"),
     "sumatory" => array("{#InvoicesLines}.price"),
     "conditions" => "MONTH({#Invoices}.sell_date) = 10"
));

CREATE TABLE `cart` (
  `id` int(11) NOT NULL auto_increment,
  `sid` char(35) default NULL,
  `product_id` int(11) NOT NULL,
  `quantity` int(11) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=UTF8;

<?php

class Products extends ActiveRecord {

     protected function readAttribute($attributeName){
          if($attributeName=="very_private_field"){
               return null;
          } else {
               return $this->$attributeName;
          }
     }

}

<?php

class Categories extends ActiveRecord {

     protected function initialize(){
          $this->setDynamicUpdate(true);
          $this->setDynamicInsert(true);
     }

}

<?php

class Inventory extends ActiveRecord {

     protected function exceptions($e){
          if($e instanceof DbConstraintViolationException){
               //Algún procedimiento
          } else {
               throw $e;
          }
     }
}

models/
     base/
          modelBase.php
     security/
          roles.php
          users.php
          access_list.php
     inventory/
          references.php
          kardex.php
     orders.php
     movement.php

[application]
mode = development
name = "Project Name"
interactive = On
dbdate = YYYY-MM-DD
debug = On

[entities]
autoInitialize = Off