Changeset 20966 for lang/php

Timestamp:

10/08/08 18:17:27 (3 months ago)

Author:

nowelium

Message:

DataSource取得について、Event方式に。selectとupdate系でdatasourceを切り替えるために。
その他もろもろあげわすれupdate

Location:

lang/php/misc/Hermit/src/Hermit

Files:

• Hermit.php (modified) (1 diff)
• HermitContext.php (added)
• HermitDataSourceManager.php (modified) (1 diff)
• HermitEvent.php (added)
• command/AbstractHermitSqlCommand.php (added)
• command/HermitDeleteCommand.php (modified) (1 diff)
• command/HermitInsertCommand.php (modified) (1 diff)
• command/HermitProcedureCommand.php (modified) (1 diff)
• command/HermitSelectCommand.php (modified) (1 diff)
• command/HermitSqlCommand.php (modified) (1 diff)
• command/HermitSqlCommandFactory.php (modified) (5 diffs)
• command/HermitUpdateCommand.php (modified) (1 diff)
• proxy/HermitClassProxy.php (modified) (1 diff)
• proxy/HermitFutureProxy.php (modified) (1 diff)
• proxy/HermitInterfaceProxy.php (modified) (2 diffs)
• proxy/HermitObjectProxy.php (modified) (1 diff)

lang/php/misc/Hermit/src/Hermit/Hermit.php

@@ -34 +34 @@
     protected static function __create($targetClass){
         if(is_object($targetClass)){
-            return HermitObjectProxy::delegate(new ReflectionObject($targetClass), $targetClass);
+            $refObject = new ReflectionObject($targetClass);
+            $ctx = new HermitContext($refObject->getName());
+            return HermitObjectProxy::delegate($ctx, $refObject, $targetClass);
         }
         $reflector = new ReflectionClass($targetClass);
+        $ctx = new HermitContext($targetClass);
         if($reflector->isInterface()){
-            return HermitInterfaceProxy::delegate($reflector);
+            return HermitInterfaceProxy::delegate($ctx, $reflector);
         }
-        return HermitClassProxy::delegate($reflector);
+        return HermitClassProxy::delegate($ctx, $reflector);
     }
     protected static function wrap(HermitProxy $proxy, $targetClass){

lang/php/misc/Hermit/src/Hermit/HermitDataSourceManager.php

@@ -6 +6 @@
 abstract class HermitDataSourceManager {
     private static $default;
+    private static $callback;
     private static $datasources = array();
     private function __construct(){
+        // mp@
     }
     public static function setDefault(PDO $default){
         self::$default = $default;
     }
+    public static function hasDefault(){
+        return null !== self::$default;
+    }
+    public static function setCallback(array $callback){
+        self::$callback = $callback;
+    }
+    public static function hasCallback(){
+        return null !== self::$callback;
+    }
     public static function set($targetClass, PDO $pdo){
         self::$datasources[$targetClass] = $pdo;
     }
-    public static function get($targetClass){
+    public static function get($targetClass, $method = null, $type = HermitEvent::UNKNOWN){
+        if(self::hasCallback()){
+            return call_user_func_array(self::$callback, array($targetClass, $method, $type));
+        }
+
         if(!self::has($targetClass)){
             return self::$default;

lang/php/misc/Hermit/src/Hermit/command/HermitDeleteCommand.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitDeleteCommand implements HermitSqlCommand {
-    public function execute(PDO $pdo, array $params){
+class HermitDeleteCommand extends AbstractHermitSqlCommand {
+    public function execute(array $parameters){
+        $pdo = $this->getConnection(HermitEvent::EVT_DELETE);
+        $builder = new HermitStatementBuilder($this->method, $this->sqlCreator);
+        $stmt = $builder->build($pdo);
+        $stmt->execute($parameters);
+        $resultset = new HermitUpdateQueryResultSet;
+        return $resultset->execute($stmt, $this->type);
     }
 }

lang/php/misc/Hermit/src/Hermit/command/HermitInsertCommand.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitInsertCommand implements HermitSqlCommand {
-  public function execute(PDO $pdo, array $parameters){
-  }
+class HermitInsertCommand extends AbstractHermitSqlCommand {
+    public function execute(array $parameters){
+        $pdo = $this->getConnection(HermitEvent::EVT_INSERT);
+        $builder = new HermitStatementBuilder($this->method, $this->sqlCreator);
+        $stmt = $builder->build($pdo);
+        $stmt->execute($parameters);
+        $resultset = new HermitUpdateQueryResultSet;
+        return $resultset->execute($stmt, $this->type);
+    }
 }

lang/php/misc/Hermit/src/Hermit/command/HermitProcedureCommand.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitProcedureCommand implements HermitSqlCommand {
-    private $method;
-    private $sqlCreator;
-    private $type;
-    private $annote;
-    public function setMethod(ReflectionMethod $method){
-        $this->method = $method;
-    }
-    public function setSqlCreator(HermitSqlCreator $sqlCreator){
-        $this->sqlCreator = $sqlCreator;
-    }
-    public function setValueType(HermitValueType $type){
-        $this->type = $type;
-    }
+class HermitProcedureCommand extends AbstractHermitSqlCommand {
+    protected $annote;
     public function setAnnote(HermitAnnote $annote){
         $this->annote = $annote;
     }
-    public function execute(PDO $pdo, array $parameters){
+    public function execute(array $parameters){
+        $pdo = $this->getConnection(HermitEvent::EVT_PROCEDURE);
         if($this->sqlCreator instanceof HermiSetupSqlCreator){
             if($this->sqlCreator->hasSetupSql()){

lang/php/misc/Hermit/src/Hermit/command/HermitSelectCommand.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitSelectCommand implements HermitSqlCommand {
-    private $method;
-    private $sqlCreator;
-    private $type;
-    public function __construct(ReflectionMethod $method, HermitSqlCreator $sqlCreator, HermitValueType $type){
-        $this->method = $method;
-        $this->sqlCreator = $sqlCreator;
-        $this->type = $type;
-    }
-    public function execute(PDO $pdo, array $parameters){
+class HermitSelectCommand extends AbstractHermitSqlCommand {
+    public function execute(array $parameters){
+        $pdo = $this->getConnection(HermitEvent::EVT_SELECT);
         $builder = new HermitStatementBuilder($this->method, $this->sqlCreator);
         $stmt = $builder->build($pdo);

lang/php/misc/Hermit/src/Hermit/command/HermitSqlCommand.php

@@ -5 +5 @@
  */
 interface HermitSqlCommand {
-    public function execute(PDO $pdo, array $params);
+    public function execute(array $params);
 }

lang/php/misc/Hermit/src/Hermit/command/HermitSqlCommandFactory.php

@@ -6 +6 @@
 class HermitSqlCommandFactory {
 
+    protected $context;
     protected $annote;
     protected $reflector;
     protected $createdCommands = array();
 
-    public function __construct(ReflectionClass $reflector){
+    public function __construct(HermitContext $ctx, ReflectionClass $reflector){
+        $this->context = $ctx;
         $this->annote = HermitAnnote::create($reflector);
         $this->reflector = $reflector;
@@ -17 +19 @@
         return $this->annote->hasMethod($methodName);
     }
-    public function create(PDO $pdo, $methodName){
+    public function create($methodName){
         if(isset($this->createdCommands[$methodName])){
             return $this->createdCommands[$methodName];
         }
         $method = $this->annote->getMethod($methodName);
-        $command = $this->createCommand($pdo, $method);
+        $command = $this->createCommand($method);
         return $this->createdCommands[$methodName] = $command;
     }
-    protected function createCommand(PDO $pdo, ReflectionMethod $method){
+    protected function createCommand(ReflectionMethod $method){
         $methodName = $method->getName();
+        $pdo = HermitDataSourceManager::get($this->context->getTargetClass(), $methodName, HermitEvent::EVT_SETUP);
         if($this->annote->isProcedureMethod($method)){
             return $this->createProcedureCommand($pdo, $method);
@@ -48 +51 @@
 
         $command = new HermitProcedureCommand;
+        $command->setContext($this->context);
         $command->setMethod($method);
         $command->setSqlCreator($creator);
@@ -69 +73 @@
         throw new BadMethodCallException('method: "' . $method->getName() . '" was not apply to Procedure command');
     }
-    protected function createInsertCommand(ReflectionMethod $method){
-        throw new RuntimeException('T.B.D');
+    protected function createInsertCommand(PDO $pdo, ReflectionMethod $method){
+        $dbms = HermitDatabaseMetaFactory::getDbms($pdo);
+        $creator = $this->createInsertSqlCreator($method, $dbms);
+        $creator->initialize($pdo, $method, $this->annote);
+        $valueType = HermitValueTypeFactory::create($this->annote, $method);
+        $command = new HermitInsertCommand;
+        $command->setContext($this->context);
+        $command->setMethod($method);
+        $command->setSqlCreator($creator);
+        $command->setValueType($valueType);
+        return $command;
     }
-    protected function createUpdateCommand(ReflectionMethod $method){
-        throw new RuntimeException('T.B.D');
+    protected function createInsertSqlCreator($method, $dbms){
+        $sql = $this->annote->getSql($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        $sql = $this->annote->getFile($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        return new HermitAutoInsertSqlCreator;
     }
-    protected function createDeleteCommand(ReflectionMethod $method){
-        throw new RuntimeException('T.B.D');
+    protected function createUpdateCommand(PDO $pdo, ReflectionMethod $method){
+        $dbms = HermitDatabaseMetaFactory::getDbms($pdo);
+        $creator = $this->createUpdateSqlCreator($method, $dbms);
+        $creator->initialize($pdo, $method, $this->annote);
+        $valueType = HermitValueTypeFactory::create($this->annote, $method);
+        $command = new HermitUpdateCommand;
+        $command->setContext($this->context);
+        $command->setMethod($method);
+        $command->setSqlCreator($creator);
+        $command->setValueType($valueType);
+        return $command;
+    }
+    protected function createUpdateSqlCreator($method, $dbms){
+        $sql = $this->annote->getSql($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        $sql = $this->annote->getFile($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        return new HermitAutoUpdateSqlCreator;
+    }
+    protected function createDeleteCommand(PDO $pdo, ReflectionMethod $method){
+        $dbms = HermitDatabaseMetaFactory::getDbms($pdo);
+        $creator = $this->createDeleteSqlCreator($method, $dbms);
+        $creator->initialize($pdo, $method, $this->annote);
+        $valueType = HermitValueTypeFactory::create($this->annote, $method);
+        $command = new HermitDeleteCommand;
+        $command->setContext($this->context);
+        $command->setMethod($method);
+        $command->setSqlCreator($creator);
+        $command->setValueType($valueType);
+        return $command;
+    }
+    protected function createDeleteSqlCreator($method, $dbms){
+        $sql = $this->annote->getSql($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        $sql = $this->annote->getFile($method, $dbms);
+        if(null !== $sql){
+            return new HermitStaticSqlCreator($sql);
+        }
+        return new HermitAutoDeleteSqlCreator;
     }
     protected function createSelectCommand(PDO $pdo, ReflectionMethod $method){
@@ -86 +150 @@
         }
         $valueType = HermitValueTypeFactory::create($this->annote, $method);
-        return new HermitSelectCommand($method, $creator, $valueType);
+        $command = new HermitSelectCommand;
+        $command->setContext($this->context);
+        $command->setMethod($method);
+        $command->setSqlCreator($creator);
+        $command->setValueType($valueType);
+        return $command;
     }
     protected function createSelectSqlCreator(ReflectionMethod $method, $dbms){

lang/php/misc/Hermit/src/Hermit/command/HermitUpdateCommand.php

@@ -4 +4 @@
  * @author nowelium
  */
-class HermitUpdateCommand implements HermitSqlCommand {
-    public function execute(PDO $pdo, array $params){
+class HermitUpdateCommand extends AbstractHermitSqlCommand {
+    public function execute(array $parameters){
+        $pdo = $this->getConnection(HermitEvent::EVT_UPDATE);
+        $builder = new HermitStatementBuilder($this->method, $this->sqlCreator);
+        $stmt = $builder->build($pdo);
+        $stmt->execute($parameters);
+        $resultset = new HermitUpdateQueryResultSet;
+        return $resultset->execute($stmt, $this->type);
     }
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitClassProxy.php

@@ -5 +5 @@
  */
 class HermitClassProxy implements HermitFutureProxy {
+    private $context;
     private $reflector;
-    protected function __construct(ReflectionClass $reflector){
+    protected function __construct(HermitContext $ctx, ReflectionClass $reflector){
+        $this->context = $ctx;
         $this->reflector = $reflector;
     }
-    public static function delegate(ReflectionClass $reflector, $instance = null){
-        return new self($reflector);
+    public static function delegate(HermitContext $ctx, ReflectionClass $reflector, $instance = null){
+        return new self($ctx, $reflector);
     }
     public function request($name, array $params){
+        throw new RuntimeException('T.B.D');
     }
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitFutureProxy.php

@@ -5 +5 @@
  */
 interface HermitFutureProxy extends HermitProxy {
-    public static function delegate(ReflectionClass $reflector, $instance = null);
+    public static function delegate(HermitContext $ctx, ReflectionClass $reflector, $instance = null);
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitInterfaceProxy.php

@@ -5 +5 @@
  */
 class HermitInterfaceProxy implements HermitFutureProxy {
+    protected $context;
     protected $reflector;
     protected $commandFactory;
-    protected function __construct(ReflectionClass $reflector){
+    protected function __construct(HermitContext $ctx, ReflectionClass $reflector){
+        $this->context = $ctx;
         $this->reflector = $reflector;
-        $this->commandFactory = new HermitSqlCommandFactory($reflector);
+        $this->commandFactory = new HermitSqlCommandFactory($ctx, $reflector);
     }
-    public static function delegate(ReflectionClass $reflector, $instance = null){
-        return new self($reflector);
+    public static function delegate(HermitContext $ctx, ReflectionClass $reflector, $instance = null){
+        return new self($ctx, $reflector);
     }
     public function request($name, array $params){
@@ -18 +20 @@
             throw new BadMethodCallException($this->reflector->getName() . '::' . $name);
         }
-        $pdo = HermitDataSourceManager::get($this->reflector->getName());
-        $command = $this->commandFactory->create($pdo, $name);
-        return $command->execute($pdo, $params);
+        $command = $this->commandFactory->create($this->context, $name);
+        return $command->execute($params);
     }
 }

lang/php/misc/Hermit/src/Hermit/proxy/HermitObjectProxy.php

@@ -5 +5 @@
  */
 class HermitObjectProxy implements HermitFutureProxy {
+    protected $context;
     protected $target;
     protected $annote;
-    protected function __construct(ReflectionClass $reflector, $target){
+    protected function __construct(HermitContext $ctx, ReflectionClass $reflector, $target){
+        $this->context = $ctx;
         $this->target = $target;
         $this->annote = HermitAnnote::create($reflector);
     }
-    public static function delegate(ReflectionClass $reflector, $instance = null){
-        return new self($reflector, $instance);
+    public static function delegate(HermitContext $ctx, ReflectionClass $reflector, $instance = null){
+        return new self($ctx, $reflector, $instance);
     }
     public function request($name, array $params){