Added a folder remotely

Doctrine/Session/Common.php

+<?php
+Doctrine::autoload('Doctrine_Session');
+/**
+ * standard session, the parent of pgsql, mysql and sqlite
+ */
+class Doctrine_Session_Common extends Doctrine_Session {
+    public function modifyLimitQuery($query,$limit = false,$offset = false) {
+        if($limit && $offset) {
+            $query .= " LIMIT ".$limit." OFFSET ".$offset;
+        } elseif($limit && ! $offset) {
+            $query .= " LIMIT ".$limit;
+        } elseif( ! $limit && $offset) {
+            $query .= " LIMIT 999999999999 OFFSET ".$offset;
+        }
+
+        return $query;
+    }
+}
+?>

Doctrine/Session/Exception.php

+<?php
+require_once(Doctrine::getPath().DIRECTORY_SEPARATOR."Exception.php");
+/**
+ * thrown when user tries to get the current 
+ * session and there are no open sessions
+ */
+class Doctrine_Session_Exception extends Doctrine_Exception {
+    public function __construct() {
+        parent::__construct("There are no opened sessions. Use 
+                             Doctrine_Manager::getInstance()->openSession() to open a new session.",Doctrine::ERR_NO_SESSIONS);
+    }
+}
+?>

Doctrine/Session/Firebird.php

+<?php
+Doctrine::autoload('Doctrine_Session');
+/**
+ * firebird driver
+ */
+class Doctrine_Session_Firebird extends Doctrine_Session {
+    public function modifyLimitQuery($query,$limit,$offset) {
+        return preg_replace("/([\s(])*SELECT/i","\\1SELECT TOP($from, $count)", $query);
+    }
+    /**
+     * returns the next value in the given sequence
+     * @param string $sequence
+     * @return integer
+     */
+    public function getNextID($sequence) {
+        $stmt = $this->query("SELECT UNIQUE FROM ".$sequence);
+        $data = $stmt->fetch(PDO::FETCH_NUM);
+        return $data[0];
+    }
+}
+?>

Doctrine/Session/Informix.php

+<?php
+Doctrine::autoload('Doctrine_Session');
+/**
+ * informix database driver
+ */
+class Doctrine_Session_Informix extends Doctrine_Session { }
+?>

Doctrine/Session/Mssql.php

+<?php
+Doctrine::autoload('Doctrine_Session');
+/**
+ * mssql driver
+ */
+class Doctrine_Session_Mssql extends Doctrine_Session {
+    /**
+     * returns the next value in the given sequence
+     * @param string $sequence
+     * @return integer
+     */
+    public function getNextID($sequence) {
+        $this->query("INSERT INTO $sequence (vapor) VALUES (0)");
+        $stmt = $this->query("SELECT @@IDENTITY FROM $sequence");
+        $data = $stmt->fetch(PDO::FETCH_NUM);
+        return $data[0];
+    }
+}
+?>

Doctrine/Session/Mysql.php

+<?php
+require_once("Common.php");
+/**
+ * mysql driver
+ */
+class Doctrine_Session_Mysql extends Doctrine_Session_Common {
+
+    /**
+     * the constructor
+     * @param PDO $pdo  -- database handle
+     */
+    public function __construct(Doctrine_Manager $manager,PDO $pdo) {
+        $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
+        parent::__construct($manager,$pdo);
+    }
+    /**
+     * deletes all data access object from the collection
+     * @param Doctrine_Collection $coll
+     */
+     /**
+    public function deleteCollection(Doctrine_Collection $coll) {
+
+        $a   = $coll->getTable()->getCompositePaths();
+        $a   = array_merge(array($coll->getTable()->getComponentName()),$a);
+
+        $graph = new Doctrine_DQL_Parser($this);
+        foreach($coll as $k=>$record) {
+            switch($record->getState()):
+                case Doctrine_Record::STATE_DIRTY:
+                case Doctrine_Record::STATE_CLEAN:
+                    $ids[] = $record->getID();
+                break;
+            endswitch;
+        }
+        if(empty($ids))
+            return array();
+
+        $graph->parseQuery("FROM ".implode(", ",$a)." WHERE ".$coll->getTable()->getTableName().".id IN(".implode(", ",$ids).")");
+
+        $query = $graph->buildDelete();
+
+        $this->getDBH()->query($query);
+        return $ids;
+    }
+    */
+
+    /**
+     * returns maximum identifier values
+     *
+     * @param array $names          an array of component names
+     * @return array
+     */
+    public function getMaximumValues2(array $names) { 
+        $values = array();
+        foreach($names as $name) {
+            $table     = $this->tables[$name];
+            $keys      = $table->getPrimaryKeys();
+            $tablename = $table->getTableName();
+
+            if(count($keys) == 1 && $keys[0] == $table->getIdentifier()) {
+                // record uses auto_increment column
+
+                $sql[]    = "SELECT MAX(".$tablename.".".$table->getIdentifier().") as $tablename FROM ".$tablename;
+                $values[$tablename] = 0;
+                $array[] = $tablename;
+            }
+        }
+        $sql    = implode(" UNION ",$sql);
+        $stmt   = $this->getDBH()->query($sql);
+        $data   = $stmt->fetchAll(PDO::FETCH_NUM);
+
+        foreach($data as $k => $v) {
+            $values[$array[$k]] = $v[0];
+        }
+        return $values;
+    }
+    /**
+     * bulkInsert
+     * inserts all the objects in the pending insert list into database
+     * TODO: THIS IS NOT WORKING YET AS THERE ARE BUGS IN COMPONENTS USING SELF-REFERENCENCING
+     *
+     * @return boolean
+     */
+     
+     /**
+    public function bulkInsert() {
+        if(empty($this->insert))
+            return false;
+
+        foreach($this->insert as $name => $inserts) {
+            if( ! isset($inserts[0]))
+                continue;
+
+            $record    = $inserts[0];
+            $table     = $record->getTable();
+            $seq       = $table->getSequenceName();
+            $keys      = $table->getPrimaryKeys();
+
+            $marks = array();
+            $params = array();
+            foreach($inserts as $k => $record) {
+                $record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onPreSave($record);
+                // listen the onPreInsert event
+                $record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onPreInsert($record);
+
+                $array = $record->getPrepared();
+
+                if(isset($this->validator)) {
+                    if( ! $this->validator->validateRecord($record)) {
+                        continue;
+                    }
+                }
+
+                $key = implode(", ",array_keys($array));
+                if( ! isset($params[$key]))
+                    $params[$key] = array();
+
+                $marks[$key][] = "(".substr(str_repeat("?, ",count($array)),0,-2).")";
+                $params[$key] = array_merge($params[$key], array_values($array));
+
+
+                // listen the onInsert event
+                $record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onInsert($record);
+
+                $record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onSave($record);
+            }
+
+            if( ! empty($marks)) {
+                foreach($marks as $key => $list) {
+                    $query = "INSERT INTO ".$table->getTableName()." (".$key.") VALUES ".implode(", ", $list);
+                    $stmt  = $this->getDBH()->prepare($query);
+                    $stmt->execute($params[$key]);
+                }
+            }
+            if(count($keys) == 1 && $keys[0] == $table->getIdentifier()) {
+
+                // record uses auto_increment column
+
+                $sql  = "SELECT MAX(".$table->getIdentifier().") FROM ".$record->getTable()->getTableName();
+                $stmt = $this->getDBH()->query($sql);
+                $data = $stmt->fetch(PDO::FETCH_NUM);
+                $id   = $data[0];
+                $stmt->closeCursor();
+                
+                foreach(array_reverse($inserts) as $record) {
+
+                    $record->setID((int) $id);
+                    $id--;
+                }
+            }
+        }
+
+        $this->insert = array();
+        return true;
+    }
+    */
+
+}
+?>

Doctrine/Session/Oracle.php

+<?php
+Doctrine::autoload('Doctrine_Session');
+/**
+ * oracle driver
+ */
+class Doctrine_Session_Oracle extends Doctrine_Session {
+    public function modifyLimitQuery($query,$limit,$offset) {
+        $e      = explode("select ",strtolower($query));
+        $e2     = explode(" from ",$e[1]);
+        $fields = $e2[0];
+
+        $query = "SELECT $fields FROM (SELECT rownum as linenum, $fields FROM ($query) WHERE rownum <= ($offset + $limit)) WHERE linenum >= ".++$offset;
+        return $query;
+    }
+    /**
+     * returns the next value in the given sequence
+     * @param string $sequence
+     * @return integer
+     */
+    public function getNextID($sequence) {
+        $stmt = $this->query("SELECT $sequence.nextval FROM dual");
+        $data = $stmt->fetch(PDO::FETCH_NUM);
+        return $data[0];
+    }
+}
+?>

Doctrine/Session/Pgsql.php

+<?php
+require_once("Common.php");
+/**
+ * pgsql driver
+ */
+class Doctrine_Session_Pgsql extends Doctrine_Session_Common {
+    /**
+     * returns the next value in the given sequence
+     * @param string $sequence
+     * @return integer
+     */
+    public function getNextID($sequence) {
+        $stmt = $this->query("SELECT NEXTVAL('$sequence')");
+        $data = $stmt->fetch(PDO::FETCH_NUM);
+        return $data[0];
+    }
+}
+?>

Doctrine/Session/Sqlite.php

+<?php
+require_once("Common.php");
+/**
+ * sqlite driver
+ */
+class Doctrine_Session_Sqlite extends Doctrine_Session_Common { }  
+?>