/redbean/rb.php

Large files files are truncated, but you can click here to view the full file

<?php /*

                   .______.
_______   ____   __| _/\_ |__   ____ _____    ____
\_  __ \_/ __ \ / __ |  | __ \_/ __ \\__  \  /    \
 |  | \/\  ___// /_/ |  | \_\ \  ___/ / __ \|   |  \
 |__|    \___  >____ |  |___  /\___  >____  /___|  /
             \/     \/      \/     \/     \/     \/



RedBean Database Objects -
Written by Gabor de Mooij (c) copyright 2009-2012

RedBean is DUAL Licensed BSD and GPLv2. You may choose the license that fits
best for your project.


BSD/GPLv2 License

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of RedBeanPHP nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.


THIS SOFTWARE IS PROVIDED BY GABOR DE MOOIJ ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL GABOR DE MOOIJ BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

RedBeanPHP is Written by Gabor de Mooij (G.J.G.T de Mooij) Copyright (c) 2011.


GPLv2 LICENSE


        GNU GENERAL PUBLIC LICENSE
           Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

          Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

        GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

          NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

*/


/**
 * Interface for database drivers
 *
 * @file			RedBean/Driver.php
 * @description		Describes the API for database classes
 *					The Driver API conforms to the ADODB pseudo standard
 *					for database drivers.
 * @author			Gabor de Mooij and the RedBeanPHP Community
 * @license			BSD/GPLv2
 *
 *
 * copyright (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community
 * This source file is subject to the BSD/GPLv2 License that is bundled
 * with this source code in the file license.txt.
 */
interface RedBean_Driver {
  /**
   * Runs a query and fetches results as a multi dimensional array.
   *
   * @param  string $sql SQL to be executed
   *
   * @return array $results result
   */
  public function GetAll( $sql, $aValues=array() );

  /**
   * Runs a query and fetches results as a column.
   *
   * @param  string $sql SQL Code to execute
   *
   * @return array	$results Resultset
   */
  public function GetCol( $sql, $aValues=array() );

  /**
   * Runs a query an returns results as a single cell.
   *
   * @param string $sql SQL to execute
   *
   * @return mixed $cellvalue result cell
   */
  public function GetCell( $sql, $aValues=array() );

  /**
   * Runs a query and returns a flat array containing the values of
   * one row.
   *
   * @param string $sql SQL to execute
   *
   * @return array $row result row
   */
  public function GetRow( $sql, $aValues=array() );

  /**
   * Executes SQL code and allows key-value binding.
   * This function allows you to provide an array with values to bind
   * to query parameters. For instance you can bind values to question
   * marks in the query. Each value in the array corresponds to the
   * question mark in the query that matches the position of the value in the
   * array. You can also bind values using explicit keys, for instance
   * array(":key"=>123) will bind the integer 123 to the key :key in the
   * SQL. This method has no return value.
   *
   * @param string $sql	  SQL Code to execute
   * @param array  $aValues Values to bind to SQL query
   *
   * @return void
   */
  public function Execute( $sql, $aValues=array() );

  /**
   * Escapes a string for use in SQL using the currently selected
   * driver driver.
   *
   * @param string $string string to be escaped
   *
   * @return string $string escaped string
   */
  public function Escape( $str );

  /**
   * Returns the latest insert ID if driver does support this
   * feature.
   *
   * @return integer $id primary key ID
   */
  public function GetInsertID();


  /**
   * Returns the number of rows affected by the most recent query
   * if the currently selected driver driver supports this feature.
   *
   * @return integer $numOfRows number of rows affected
   */
  public function Affected_Rows();

  /**
   * Toggles debug mode. In debug mode the driver will print all
   * SQL to the screen together with some information about the
   * results. All SQL code that passes through the driver will be
   * passes on to the screen for inspection.
   * This method has no return value.
   *
   * @param boolean $trueFalse turn on/off
   *
   * @return void
   */
  public function setDebugMode( $tf );

  /**
   * Starts a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function CommitTrans();

  /**
   * Commits a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function StartTrans();

  /**
   * Rolls back a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function FailTrans();
}


/**
 * PDO Driver
 * @file			RedBean/PDO.php
 * @description		PDO Driver
 *					This Driver implements the RedBean Driver API
 * @author			Gabor de Mooij and the RedBeanPHP Community, Desfrenes
 * @license			BSD/GPLv2
 *
 *
 * (c) copyright Desfrenes & Gabor de Mooij and the RedBeanPHP community
 * This source file is subject to the BSD/GPLv2 License that is bundled
 * with this source code in the file license.txt.
 *
 */
class RedBean_Driver_PDO implements RedBean_Driver {


  /**
   * Contains database DSN for connecting to database.
   * @var string
   */
  protected $dsn;

  /**
   * Whether we are in debugging mode or not.
   * @var boolean
   */
  protected $debug = false;

  /**
   * Holds an instance of ILogger implementation.
   * @var RedBean_ILogger
   */
  protected $logger = NULL;

  /**
   * Holds the PDO instance.
   * @var PDO
   */
  protected $pdo;

  /**
   * Holds integer number of affected rows from latest query
   * if driver supports this feature.
   * @var integer
   */
  protected $affected_rows;

  /**
   * Holds result resource.
   * @var integer
   */
  protected $rs;


  /**
   * Contains arbitrary connection data.
   * @var array
   */
  protected $connectInfo = array();


  /**
   * Whether you want to use classic String Only binding -
   * backward compatibility.
   * @var bool
   */
  public $flagUseStringOnlyBinding = false;

  /**
   * Whether we are currently connected or not.
   * This flag is being used to delay the connection until necessary.
   * Delaying connections is a good practice to speed up scripts that
   * don't need database connectivity but for some reason want to
   * init RedbeanPHP.
   * @var boolean
   */
  protected $isConnected = false;

  /**
   * Constructor. You may either specify dsn, user and password or
   * just give an existing PDO connection.
   * Examples:
   *    $driver = new RedBean_Driver_PDO($dsn, $user, $password);
   *    $driver = new RedBean_Driver_PDO($existingConnection);
   *
   * @param string|PDO  $dsn	 database connection string
   * @param string      $user optional
   * @param string      $pass optional
   *
   * @return void
   */
  public function __construct($dsn, $user = null, $pass = null) {
    if ($dsn instanceof PDO) {
      $this->pdo = $dsn;
      $this->isConnected = true;
      $this->pdo->setAttribute(1002, 'SET NAMES utf8');
      $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      $this->pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
      // make sure that the dsn at least contains the type
      $this->dsn = $this->getDatabaseType();
    } else {
      $this->dsn = $dsn;
      $this->connectInfo = array( 'pass'=>$pass, 'user'=>$user );
    }
  }

  /**
   * Establishes a connection to the database using PHP PDO
   * functionality. If a connection has already been established this
   * method will simply return directly. This method also turns on
   * UTF8 for the database and PDO-ERRMODE-EXCEPTION as well as
   * PDO-FETCH-ASSOC.
   *
   * @return void
   */
  public function connect() {
    if ($this->isConnected) return;
    $user = $this->connectInfo['user'];
    $pass = $this->connectInfo['pass'];
    //PDO::MYSQL_ATTR_INIT_COMMAND
    $this->pdo = new PDO(
          $this->dsn,
          $user,
          $pass,
          array(1002 => 'SET NAMES utf8',
               PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
               PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
               PDO::MYSQL_ATTR_LOCAL_INFILE => true,
          )
    );
    $this->pdo->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
    $this->isConnected = true;
  }

  /**
   * Binds parameters. This method binds parameters to a PDOStatement for
   * Query Execution. This method binds parameters as NULL, INTEGER or STRING
   * and supports both named keys and question mark keys.
   *
   * @param  PDOStatement $s       PDO Statement instance
   * @param  array        $aValues values that need to get bound to the statement
   *
   * @return void
   */
  protected function bindParams($s,$aValues) {
    foreach($aValues as $key=>&$value) {
      if (is_integer($key)) {

        if (is_null($value)){
          $s->bindValue($key+1,null,PDO::PARAM_NULL);
        }
        elseif (!$this->flagUseStringOnlyBinding && RedBean_QueryWriter_AQueryWriter::canBeTreatedAsInt($value) && $value < 2147483648) {
          $s->bindParam($key+1,$value,PDO::PARAM_INT);
        }
        else {
          $s->bindParam($key+1,$value,PDO::PARAM_STR);
        }
      }
      else {
        if (is_null($value)){
          $s->bindValue($key,null,PDO::PARAM_NULL);
        }
        elseif (!$this->flagUseStringOnlyBinding && RedBean_QueryWriter_AQueryWriter::canBeTreatedAsInt($value) &&  $value < 2147483648) {
          $s->bindParam($key,$value,PDO::PARAM_INT);
        }
        else {
          $s->bindParam($key,$value,PDO::PARAM_STR);
        }
      }

    }
  }

  /**
   * Runs a query. Internal function, available for subclasses. This method
   * runs the actual SQL query and binds a list of parameters to the query.
   * slots. The result of the query will be stored in the protected property
   * $rs (always array). The number of rows affected (result of rowcount, if supported by database)
   * is stored in protected property $affected_rows. If the debug flag is set
   * this function will send debugging output to screen buffer.
   *
   * @throws RedBean_Exception_SQL
   *
   * @param string $sql     the SQL string to be send to database server
   * @param array  $aValues the values that need to get bound to the query slots
   */
  protected function runQuery($sql,$aValues) {
    $this->connect();
    if ($this->debug && $this->logger) {
      $this->logger->log($sql, $aValues);
    }
    try {
      if (strpos('pgsql',$this->dsn)===0) {
        $s = $this->pdo->prepare($sql, array(PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT => true));
      }
      else {
        $s = $this->pdo->prepare($sql);
      }
      $this->bindParams( $s, $aValues );
      $s->execute();
      $this->affected_rows = $s->rowCount();
      if ($s->columnCount()) {
          $this->rs = $s->fetchAll();
          if ($this->debug && $this->logger) $this->logger->log('resultset: ' . count($this->rs) . ' rows');
        }
        else {
          $this->rs = array();
        }
    }catch(PDOException $e) {
      //Unfortunately the code field is supposed to be int by default (php)
      //So we need a property to convey the SQL State code.
      $x = new RedBean_Exception_SQL( $e->getMessage(), 0);
      $x->setSQLState( $e->getCode() );
      throw $x;
    }
  }


  /**
   * Runs a query and fetches results as a multi dimensional array.
   *
   * @param  string $sql SQL to be executed
   *
   * @return array $results result
   */
  public function GetAll( $sql, $aValues=array() ) {
    $this->runQuery($sql,$aValues);
    return $this->rs;
  }

   /**
   * Runs a query and fetches results as a column.
   *
   * @param  string $sql SQL Code to execute
   *
   * @return array	$results Resultset
   */
  public function GetCol($sql, $aValues=array()) {
    $rows = $this->GetAll($sql,$aValues);
    $cols = array();
    if ($rows && is_array($rows) && count($rows)>0) {
      foreach ($rows as $row) {
        $cols[] = array_shift($row);
      }
    }
    return $cols;
  }

  /**
   * Runs a query an returns results as a single cell.
   *
   * @param string $sql SQL to execute
   *
   * @return mixed $cellvalue result cell
   */
  public function GetCell($sql, $aValues=array()) {
    $arr = $this->GetAll($sql,$aValues);
    $row1 = array_shift($arr);
    $col1 = array_shift($row1);
    return $col1;
  }

  /**
   * Runs a query and returns a flat array containing the values of
   * one row.
   *
   * @param string $sql SQL to execute
   *
   * @return array $row result row
   */
  public function GetRow($sql, $aValues=array()) {
    $arr = $this->GetAll($sql, $aValues);
    return array_shift($arr);
  }



  /**
   * Executes SQL code and allows key-value binding.
   * This function allows you to provide an array with values to bind
   * to query parameters. For instance you can bind values to question
   * marks in the query. Each value in the array corresponds to the
   * question mark in the query that matches the position of the value in the
   * array. You can also bind values using explicit keys, for instance
   * array(":key"=>123) will bind the integer 123 to the key :key in the
   * SQL. This method has no return value.
   *
   * @param string $sql	  SQL Code to execute
   * @param array  $aValues Values to bind to SQL query
   *
   * @return void
   */
  public function Execute( $sql, $aValues=array() ) {
    $this->runQuery($sql,$aValues);
    return $this->affected_rows;
  }

  /**
   * Escapes a string for use in SQL using the currently selected
   * PDO driver.
   *
   * @param string $string string to be escaped
   *
   * @return string $string escaped string
   */
  public function Escape( $str ) {
    $this->connect();
    return substr(substr($this->pdo->quote($str), 1), 0, -1);
  }

  /**
   * Returns the latest insert ID if driver does support this
   * feature.
   *
   * @return integer $id primary key ID
   */
  public function GetInsertID() {
    $this->connect();
    return (int) $this->pdo->lastInsertId();
  }

  /**
   * Returns the number of rows affected by the most recent query
   * if the currently selected PDO driver supports this feature.
   *
   * @return integer $numOfRows number of rows affected
   */
  public function Affected_Rows() {
    $this->connect();
    return (int) $this->affected_rows;
  }

  /**
   * Toggles debug mode. In debug mode the driver will print all
   * SQL to the screen together with some information about the
   * results. All SQL code that passes through the driver will be
   * passes on to the screen for inspection.
   * This method has no return value.
   *
   * Additionally you can inject RedBean_ILogger implementation
   * where you can define your own log() method
   *
   * @param boolean $trueFalse turn on/off
   * @param RedBean_ILogger $logger
   *
   * @return void
   */
  public function setDebugMode( $tf, $logger = NULL ) {
    $this->connect();
    $this->debug = (bool)$tf;
    if ($this->debug and !$logger) $logger = new RedBean_Logger();
    $this->setLogger($logger);
  }


  /**
   * Injects RedBean_ILogger object.
   *
   * @param RedBean_ILogger $logger
   */
  public function setLogger( RedBean_ILogger $logger ) {
    $this->logger = $logger;
  }

  /**
   * Gets RedBean_ILogger object.
   *
   * @return RedBean_ILogger
   */
  public function getLogger() {
    return $this->logger;
  }

  /**
   * Starts a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function StartTrans() {
    $this->connect();
    $this->pdo->beginTransaction();
  }

  /**
   * Commits a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function CommitTrans() {
    $this->connect();
    $this->pdo->commit();
  }

  /**
   * Rolls back a transaction.
   * This method is part of the transaction mechanism of
   * RedBeanPHP. All queries in a transaction are executed together.
   * In case of an error all commands will be rolled back so none of the
   * SQL in the transaction will affect the DB. Using transactions is
   * considered best practice.
   * This method has no return value.
   *
   * @return void
   */
  public function FailTrans() {
    $this->connect();
    $this->pdo->rollback();
  }

  /**
   * Returns the name of the database type/brand: i.e. mysql, db2 etc.
   *
   * @return string $typeName database identification
   */
  public function getDatabaseType() {
    $this->connect();
    return $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME);
  }

  /**
   * Returns the version number of the database.
   *
   * @return mixed $version version number of the database
   */
  public function getDatabaseVersion() {
    $this->connect();
    return $this->pdo->getAttribute(PDO::ATTR_CLIENT_VERSION);
  }

  /**
   * Returns the underlying PHP PDO instance.
   *
   * @return PDO $pdo PDO instance used by PDO wrapper
   */
  public function getPDO() {
    $this->connect();
    return $this->pdo;
  }

  /**
   * Closes database connection by destructing PDO.
   */
  public function close() {
    $this->pdo = null;
    $this->isConnected = false;
  }

  /**
   * Returns TRUE if the current PDO instance is connected.
   *
   * @return boolean $yesNO
   */
  public function isConnected() {
    if (!$this->isConnected && !$this->pdo) return false;
    return true;
  }


}



/**
 * RedBean_OODBBean (Object Oriented DataBase Bean)
 *
 * @file 			RedBean/RedBean_OODBBean.php
 * @description		The Bean class used for passing information
 *
 * @author			Gabor de Mooij and the RedBeanPHP community
 * @license			BSD/GPLv2
 *
 *
 * copyright (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community.
 * This source file is subject to the BSD/GPLv2 License that is bundled
 * with this source code in the file license.txt.
 */
class RedBean_OODBBean implements IteratorAggregate, ArrayAccess, Countable {

    /**
     * Reference to NULL property for magic getter.
     * @var Null $null
     */
    private $null = null;


  /**
   * Properties of the bean. These are kept in a private
   * array called properties and exposed through the array interface.
   * @var array $properties
   */
  private $properties = array();

  /**
   * Meta Data storage. This is the internal property where all
   * Meta information gets stored.
   * @var array
   */
  private $__info = NULL;

  /**
   * Contains a BeanHelper to access service objects like
   * te association manager and OODB.
   * @var RedBean_BeanHelper
   */
  private $beanHelper = NULL;

  /**
   * Contains the latest Fetch Type.
   * A Fetch Type is a preferred type for the next nested bean.
   * @var null
   */
  private $fetchType = NULL;

  /** Returns the alias for a type
   *
   * @param  $type aliased type
   *
   * @return string $type type
   */
  private function getAlias( $type ) {
    if ($this->fetchType) {
      $type = $this->fetchType;
      $this->fetchType = null;
    }
    return $type;
  }

  /**
   * Sets the Bean Helper. Normally the Bean Helper is set by OODB.
   * Here you can change the Bean Helper. The Bean Helper is an object
   * providing access to a toolbox for the bean necessary to retrieve
   * nested beans (bean lists: ownBean,sharedBean) without the need to
   * rely on static calls to the facade (or make this class dep. on OODB).
   *
   * @param RedBean_IBeanHelper $helper
   * @return void
   */
  public function setBeanHelper(RedBean_IBeanHelper $helper) {
    $this->beanHelper = $helper;
  }


  /**
   * Returns an ArrayIterator so you can treat the bean like
   * an array with the properties container as its contents.
   *
   * @return ArrayIterator $arrayIt an array iterator instance with $properties
   */
  public function getIterator() {
    return new ArrayIterator($this->properties);
  }

  /**
   * Imports all values in associative array $array. Every key is used
   * for a property and every value will be assigned to the property
   * identified by the key. So basically this method converts the
   * associative array to a bean by loading the array. You can filter
   * the values using the $selection parameter. If $selection is boolean
   * false, no filtering will be applied. If $selection is an array
   * only the properties specified (as values) in the $selection
   * array will be taken into account. To skip a property, omit it from
   * the $selection array. Also, instead of providing an array you may
   * pass a comma separated list of property names. This method is
   * chainable because it returns its own object.
   * Imports data into bean
   *
   * @param array        $array     what you want to import
   * @param string|array $selection selection of values
   * @param boolean      $notrim    if TRUE values will not be trimmed
   *
   *    @return RedBean_OODBBean $this
   */
  public function import( $arr, $selection=false, $notrim=false ) {
    if (is_string($selection)) $selection = explode(',',$selection);
    //trim whitespaces
    if (!$notrim && is_array($selection)) foreach($selection as $k=>$s){ $selection[$k]=trim($s); }
    foreach($arr as $k=>$v) {
      if ($k!='__info') {
        if (!$selection || ($selection && in_array($k,$selection))) {
          $this->$k = $v;
        }
      }
    }
    return $this;
  }

  /**
   * Very superficial export function
   * @return array $properties
   */
  public function getProperties() {
    return $this->properties;
  }

  /**
   * Exports the bean as an array.
   * This function exports the contents of a bean to an array and returns
   * the resulting array. If $meta eq uals boolean TRUE, then the array will
   * also contain the __info section containing the meta data inside the
   * RedBean_OODBBean Bean object.
   * @param boolean $meta
   * @return array $arr
   */
  public function export($meta = false) {
    //$arr = $this->properties;
    $arr=array();
    foreach($this as $k=>$v) {
      if (is_array($v)) foreach($v as $i=>$b) $v[$i]=$b->export();
      $arr[$k] = $v;
    }
    if ($meta) $arr['__info'] = $this->__info;
    return $arr;
  }

  /**
   * Exports the bean to an object.
   * This function exports the contents of a bean to an object.
   * @param object $obj
   * @return array $arr
   */
  public function exportToObj($obj) {
    foreach($this->properties as $k=>$v) {
      if (!is_array($v) && !is_object($v))
      $obj->$k = $v;
    }
  }

  /**
   * Implements isset() function for use as an array.
   * Returns whether bean has an element with key
   * named $property. Returns TRUE if such an element exists
   * and FALSE otherwise.
   * @param string $property
   * @return boolean $hasProperty
   */
  public function __isset($property) {
    return (isset($this->properties[$property]));
  }



  /**
   * Returns the ID of the bean no matter what the ID field is.
   *
   * @return string $id record Identifier for bean
   */
  public function getID() {
    return (string) $this->id;
  }

  /**
   * Unsets a property. This method will load the property first using
   * __get.
   *
   * @param  string $property property
   *
   * @return void
   */
  public function __unset($property) {
    $this->__get($property);
    $fieldLink = $property.'_id';
    if (isset($this->$fieldLink)) {
      //wanna unset a bean reference?
      $this->$fieldLink = null;
    }
    if ((isset($this->properties[$property]))) {
      unset($this->properties[$property]);
    }
  }

  /**
   * Removes a property from the properties list without invoking
   * an __unset on the bean.
   *
   * @param  string $property property that needs to be unset
   *
   * @return void
   */
  public function removeProperty( $property ) {
    unset($this->properties[$property]);
  }


  /**
   * Magic Getter. Gets the value for a specific property in the bean.
   * If the property does not exist this getter will make sure no error
   * occurs. This is because RedBean allows you to query (probe) for
   * properties. If the property can not be found this method will
   * return NULL instead.
   * @param string $property
   * @return mixed $value
   */
  public function &__get( $property ) {
    if ($this->beanHelper)
    $toolbox = $this->beanHelper->getToolbox();
    if (!isset($this->properties[$property])) {
      $fieldLink = $property.'_id';
      /**
       * All this magic can be become very complex quicly. For instance,
       * my PHP CLI produced a segfault while testing this code. Turns out that
       * if fieldlink equals idfield, scripts tend to recusrively load beans and
       * instead of giving a clue they simply crash and burn isnt that nice?
       */
      if (isset($this->$fieldLink) && $fieldLink != $this->getMeta('sys.idfield')) {
        $this->setMeta('tainted',true);
        $type =  $this->getAlias($property);
        $targetType = $this->properties[$fieldLink];
        $bean =  $toolbox->getRedBean()->load($type,$targetType);
        //return $bean;
        $this->properties[$property] = $bean;
        return $this->properties[$property];
      }
      if (strpos($property,'own')===0) {
        $firstCharCode = ord(substr($property,3,1));
        if ($firstCharCode>=65 && $firstCharCode<=90) {
          $type = (__lcfirst(str_replace('own','',$property)));
          $myFieldLink = $this->getMeta('type').'_id';
          $beans = $toolbox->getRedBean()->find($type,array(),array(" $myFieldLink = ? ",array($this->getID())));
          $this->properties[$property] = $beans;
          $this->setMeta('sys.shadow.'.$property,$beans);
          $this->setMeta('tainted',true);
          return $this->properties[$property];
        }
      }
      if (strpos($property,'shared')===0) {
        $firstCharCode = ord(substr($property,6,1));
        if ($firstCharCode>=65 && $firstCharCode<=90) {
          $type = (__lcfirst(str_replace('shared','',$property)));
          $keys = $toolbox->getRedBean()->getAssociationManager()->related($this,$type);
          if (!count($keys)) $beans = array(); else
          $beans = $toolbox->getRedBean()->batch($type,$keys);
          $this->properties[$property] = $beans;
          $this->setMeta('sys.shadow.'.$property,$beans);
          $this->setMeta('tainted',true);
          return $this->properties[$property];
        }
      }
      return $this->null;
    }
    return $this->properties[$property];
  }

  /**
   * Magic Setter. Sets the value for a specific property.
   * This setter acts as a hook for OODB to mark beans as tainted.
   * The tainted meta property can be retrieved using getMeta("tainted").
   * The tainted meta property indicates whether a bean has been modified and
   * can be used in various caching mechanisms.
   * @param string $property
   * @param  mixed $value
   */

  public function __set($property,$value) {
    $this->__get($property);
    $this->setMeta('tainted',true);
    $linkField = $property.'_id';
    if (isset($this->properties[$linkField]) && !($value instanceof RedBean_OODBBean)) {
      if (is_null($value) || $value === false) {
        return $this->__unset($property);
      }
      else {
        throw new RedBean_Exception_Security('Cannot cast to bean.');
      }
    }
    if ($value===false) {
      $value = '0';
    }
    if ($value===true) {
      $value = '1';
    }
    $this->properties[$property] = $value;
  }

  /**
   * Returns the value of a meta property. A meta property
   * contains extra information about the bean object that will not
   * get stored in the database. Meta information is used to instruct
   * RedBean as well as other systems how to deal with the bean.
   * For instance: $bean->setMeta("buildcommand.unique", array(
   * array("column1", "column2", "column3") ) );
   * Will add a UNIQUE constaint for the bean on columns: column1, column2 and
     * column 3.
   * To access a Meta property we use a dot separated notation.
   * If the property cannot be found this getter will return NULL instead.
   * @param string $path
   * @param mixed $default
   * @return mixed $value
   */
  public function getMeta($path,$default = NULL) {
    return (isset($this->__info[$path])) ? $this->__info[$path] : $default;
  }

  /**
   * Stores a value in the specified Meta information property. $value contains
   * the value you want to store in the Meta section of the bean and $path
   * specifies the dot separated path to the property. For instance "my.meta.property".
   * If "my" and "meta" do not exist they will be created automatically.
   * @param string $path
   * @param mixed $value
   */
  public function setMeta($path,$value) {
    $this->__info[$path] = $value;
  }

  /**
   * Copies the meta information of the specified bean
   * This is a convenience method to enable you to
   * exchange meta information easily.
   * @param RedBean_OODBBean $bean
   * @return RedBean_OODBBean
   */
  public function copyMetaFrom(RedBean_OODBBean $bean) {
    $this->__info = $bean->__info;
    return $this;
  }


  /**
   * Reroutes a call to Model if exists. (new fuse)
   * @param string $method
   * @param array $args
   * @return mixed $mixed
   */
  public function __call($method, $args) {
    return null;
    if (!isset($this->__info['model'])) {
      $model = $this->beanHelper->getModelForBean($this);
      if (!$model) return;
      $this->__info['model'] = $model;
    }
    if (!method_exists($this->__info['model'],$method)) return null;
    return call_user_func_array(array($this->__info['model'],$method), $args);
  }

  /**
   * Implementation of __toString Method
   * Routes call to Model.
   * @return string $string
   */
  public function __toString() {
    $string = $this->__call('__toString',array());
    if ($string === null) {
      return json_encode($this->properties);
    }
    else {
      return $string;
    }
  }

  /**
   * Implementation of Array Access Interface, you can access bean objects
   * like an array.
   * Call gets routed to __set.
   *
   * @param  mixed $offset offset string
   * @param  mixed $value value
   *
   * @return void
   */
  public function offsetSet($offset, $value) {
        $this->__set($offset, $value);
    }

  /**
   * Implementation of Array Access Interface, you can access bean objects
   * like an array.
   *
   * @param  mixed $offset property
   *
   * @return
   */
    public function offsetExists($offset) {
        return isset($this->properties[$offset]);
    }

  /**
   * Implementation of Array Access Interface, you can access bean objects
   * like an array.
   * Unsets a value from the array/bean.
   *
   * @param  mixed $offset property
   *
   * @return
   */
    public function offsetUnset($offset) {
        unset($this->properties[$offset]);
    }

  /**
   * Implementation of Array Access Interface, you can access bean objects
   * like an array.
   * Returns value of a property.
   *
   * @param  mixed $offset property
   *
   * @return
   */
    public function offsetGet($offset) {
        return $this->__get($offset);
    }

  /**
   * Chainable method to cast a certain ID to a bean; for instance:
   * $person = $club->fetchAs('person')->member;
   * This will load a bean of type person using member_id as ID.
   *
   * @param  string $type preferred fetch type
   *
   * @return RedBean_OODBBean
   */
  public function fetchAs($type) {
    $this->fetchType = $type;
    return $this;
  }

  /**
   * Implementation of Countable interface. Makes it possible to use
   * count() function on a bean.
   *
   * @return integer $numberOfProperties number of properties in the bean.
   */
  public function count() {
    return count($this->properties);
  }

  /**
   * Checks wether a bean is empty or not.
   * A bean is empty if it has no other properties than the id field OR
   * if all the other property are empty().
   *
   * @return boolean
   */
  public function isEmpty() {
    $empty = true;
    foreach($this->properties as $key=>$value) {
      if ($key=='id') continue;
      if (!empty($value)) {
        $empty = false;

      }
    }
    return $empty;
  }
}




/**
 * Observable
 * Base class for Observables
 *
 * @file 			RedBean/Observable.php
 * @description		Part of the observer pattern in RedBean
 *
 * @author			Gabor de Mooij and the RedBeanPHP community
 * @license			BSD/GPLv2
 *
 *
 * copyright (c) G.J.G.T. (Gabor) de Mooij and the RedBeanPHP Community.
 * This source file is subject to the BSD/GPLv2 License that is bundled
 * with this source code in the file license.txt.
 */
abstract class RedBean_Observab…

Large files files are truncated, but you can click here to view the full file