Extracted version info piggyback into its own class so it can be shared between insert and update

Author: noescom

src/Persistence/InsertPersister.php

@@ -58,6 +58,12 @@ class InsertPersister {
 		 */
 		private array $strategy_column_cache;
 
+		/**
+		 * Handles values with @Orm\Version annotations
+		 * @var VersionValueHandler
+		 */
+		private VersionValueHandler $valueHandler;
+		
 		/**
 		 * InsertPersister constructor
 		 * @param UnitOfWork $unitOfWork The UnitOfWork that will coordinate insertion operations
@@ -69,6 +75,7 @@ public function __construct(UnitOfWork $unitOfWork, ?PrimaryKeyFactory $factory
 			$this->entity_store = $unitOfWork->getEntityStore();
 			$this->property_handler = $unitOfWork->getPropertyHandler();
 			$this->connection = $unitOfWork->getConnection();
+			$this->valueHandler = new VersionValueHandler($unitOfWork->getConnection(), $unitOfWork->getEntityStore(), $unitOfWork, $unitOfWork->getPropertyHandler());
 			$this->primary_key_factory = $factory ?? new PrimaryKeyFactory();
 			$this->strategy_column_cache = [];
 		}
@@ -84,9 +91,15 @@ public function persist(object $entity): void {
 			$tableName = $this->entity_store->getOwningTable($entity);
 			$tableNameEscaped = str_replace('`', '``', $tableName);
 
+			// Fetch the column map
+			$columnMap = array_flip($this->entity_store->getColumnMap($entity));
+			
 			// Get the primary key property names and their corresponding column names
 			$primaryKeys = $this->entity_store->getIdentifierKeys($entity);
 
+			// Get the column names that make up the primary key
+			$primaryKeyColumnNames = $this->entity_store->getIdentifierColumnNames($entity);
+			
 			// Iterate through each identified primary key for the entity
 			foreach ($primaryKeys as $primaryKey) {
 				// First check if the primary key already has a value
@@ -121,22 +134,40 @@ public function persist(object $entity): void {
 			}
 
 			// Get the primary key property names and their corresponding column names
-			$versionColumnNames = $this->entity_store->getVersionColumnNames($entity);
-			
-			// Iterate through each identified primary key for the entity
-			foreach ($versionColumnNames as $property => $versionColumn) {
-				$this->property_handler->set($entity, $property, $this->getInitialVersionValue($versionColumn["column"]->getType()));
-			}
+			$versionColumns = $this->entity_store->getVersionColumnNames($entity);
+			$versionColumnNames = array_flip(array_column($versionColumns, 'name'));
 
 			// Serialize the entity into an array of column name => value pairs
 			$serializedEntity = $this->unit_of_work->getSerializer()->serialize($entity);
-			
+
 			// Create the SQL query for insertion
-			// Generates a comma-separated list of "column=:value" pairs for the SET clause
-			$sql = implode(",", array_map(
-				fn($key) => "`" . str_replace('`', '``', $key) . "`=:{$key}",
-				array_keys($serializedEntity)
-			));
+			$sqlParts = [];
+			
+			foreach ($serializedEntity as $key => $value) {
+				// Escape the identifier (add backticks)
+				$escapedKey = $this->valueHandler->escapeIdentifier($key);
+				
+				// Check if the column name exists
+				if (isset($versionColumnNames[$key])) {
+					// Fetch the column name from the map
+					$columnName = $columnMap[$key];
+					
+					// Fetch the value
+					$initialVersion = $this->getInitialVersionValue($versionColumns[$columnName]["column"]->getType());
+					
+					// Remove version property from bound parameters list
+					unset($serializedEntity[$key]);
+					
+					// Add initial value to SQL
+					$sqlParts[] = $escapedKey . "=" . $initialVersion;
+				} else {
+					// normal bound parameter
+					$sqlParts[] = $escapedKey . "=:" . $key;
+				}
+			}
+			
+			// Implode the parts
+			$sql = implode(",", $sqlParts);
 
 			// Execute the insert query with the serialized entity data as parameters
 			$rs = $this->connection->Execute("INSERT INTO `{$tableNameEscaped}` SET {$sql}", $serializedEntity);
@@ -161,11 +192,30 @@ public function persist(object $entity): void {
 					// Update the entity's property with the database-generated ID
 					// This ensures the entity's state is synchronized with its database representation
 					$this->property_handler->set($entity, $autoincrementColumn, (int)$autoIncrementId);
+					
+					// Also set it in $serializedEntity
+					$serializedEntity[$autoincrementColumn] = (int)$autoIncrementId;
 				}
 
 				// If the auto-increment ID is 0, it may indicate no new ID was generated
 				// (possibly due to a transaction rollback or other database condition)
 			}
+			
+			// Extract the primary key values from the original data
+			// These will be used in the WHERE clause to identify the record to update
+			$primaryKeyValues = array_intersect_key($serializedEntity, array_flip($primaryKeyColumnNames));
+			
+			// Fetch version values from the database (if any)
+			$fetchedDatetimeValues = $this->valueHandler->fetchUpdatedVersionValues(
+				$tableName,
+				$versionColumns,
+				$primaryKeyColumnNames,
+				$primaryKeyValues,
+			);
+			
+			// Update the entity with the new version values so the in-memory object
+			// matches the database state and can be used for subsequent operations
+			$this->valueHandler->updateEntityVersionValues($entity, $fetchedDatetimeValues);
 		}
 
 		/**
@@ -175,6 +225,7 @@ public function persist(object $entity): void {
 		 * @return string             The primary key strategy value
 		 */
 		protected function getPrimaryKeyStrategy(object $entity, string $primaryKey): string {
+			// Fetch owning table
 			$table = $this->entity_store->getOwningTable($entity);
 
 			// Fetch key from cache if present
@@ -203,7 +254,7 @@ protected function getPrimaryKeyStrategy(object $entity, string $primaryKey): st
 			return $this->strategy_column_cache[$table][$primaryKey] = "identity";
 		}
 
-		protected function getInitialVersionValue(string $columnType): \DateTimeImmutable|int|string {
+		protected function getInitialVersionValue(string $columnType): \DateTime|int|string {
 			switch ($columnType) {
 				case 'int':
 				case 'integer':
@@ -212,11 +263,11 @@ protected function getInitialVersionValue(string $columnType): \DateTimeImmutabl
 
 				case 'datetime':
 				case 'timestamp':
-					return new \DateTimeImmutable('now');
+					return "NOW()";
 
 				case 'uuid':
 				case 'guid':
-					return Tools::createGUID();
+					return "'" . Tools::createGUID() . "'";
 
 				default:
 					throw new \RuntimeException("Invalid column type {$columnType} for Version annotation");

src/Persistence/UpdatePersister.php

@@ -2,7 +2,6 @@
 
 	namespace Quellabs\ObjectQuel\Persistence;
 
-	use Quellabs\ObjectQuel\Annotations\Orm\Column;
 	use Quellabs\ObjectQuel\DatabaseAdapter\DatabaseAdapter;
 	use Quellabs\ObjectQuel\EntityStore;
 	use Quellabs\ObjectQuel\OrmException;
@@ -20,25 +19,25 @@ class UpdatePersister {
 		 * Reference to the UnitOfWork that manages persistence operations
 		 * This is a duplicate of the parent's unitOfWork property with a different naming convention
 		 */
-		protected UnitOfWork $unitOfWork;
+		private UnitOfWork $unitOfWork;
 
 		/**
 		 * The EntityStore that maintains metadata about entities and their mappings
 		 * Used to retrieve information about entity tables, columns and identifiers
 		 */
-		protected EntityStore $entityStore;
+		private EntityStore $entityStore;
 
 		/**
-		 * Utility for handling entity property access and manipulation
-		 * Provides methods to get and set entity properties regardless of their visibility
+		 * Database connection adapter used for executing SQL queries
+		 * Abstracts the underlying database system and provides a unified interface
 		 */
-		protected PropertyHandler $propertyHandler;
+		private DatabaseAdapter $connection;
 
 		/**
-		 * Database connection adapter used for executing SQL queries
-		 * Abstracts the underlying database system and provides a unified interface
+		 * Handles values with @Orm\Version annotations
+		 * @var VersionValueHandler
 		 */
-		protected DatabaseAdapter $connection;
+		private VersionValueHandler $valueHandler;
 
 		/**
 		 * UpdatePersister constructor
@@ -47,8 +46,8 @@ class UpdatePersister {
 		public function __construct(UnitOfWork $unitOfWork) {
 			$this->unitOfWork = $unitOfWork;
 			$this->entityStore = $unitOfWork->getEntityStore();
-			$this->propertyHandler = $unitOfWork->getPropertyHandler();
 			$this->connection = $unitOfWork->getConnection();
+			$this->valueHandler = new VersionValueHandler($unitOfWork->getConnection(), $unitOfWork->getEntityStore(), $unitOfWork, $unitOfWork->getPropertyHandler());
 		}
 
 		/**
@@ -60,7 +59,7 @@ public function __construct(UnitOfWork $unitOfWork) {
 		public function persist(object $entity): void {
 			// Retrieve basic information needed for the update
 			// Get the table name where the entity is stored
-			$tableName = $this->escapeIdentifier($this->entityStore->getOwningTable($entity));
+			$tableName = $this->valueHandler->escapeIdentifier($this->entityStore->getOwningTable($entity));
 
 			// Serialize the entity's current state into an array of column name => value pairs
 			$serializedEntity = $this->unitOfWork->getSerializer()->serialize($entity);
@@ -117,7 +116,7 @@ public function persist(object $entity): void {
 			}
 
 			// Fetch version values from the database (if any)
-			$fetchedDatetimeValues = $this->fetchUpdatedVersionValues(
+			$fetchedDatetimeValues = $this->valueHandler->fetchUpdatedVersionValues(
 				$tableName,
 				$versionColumns,
 				$primaryKeyColumnNames,
@@ -126,16 +125,7 @@ public function persist(object $entity): void {
 
 			// Update the entity with the new version values so the in-memory object
 			// matches the database state and can be used for subsequent operations
-			$this->updateEntityVersionValues($entity, $fetchedDatetimeValues);
-		}
-		
-		/**
-		 * Escapes a database identifier (table or column name)
-		 * @param string $identifier The identifier to escape
-		 * @return string The escaped identifier wrapped in backticks
-		 */
-		protected function escapeIdentifier(string $identifier): string {
-			return '`' . str_replace('`', '``', $identifier) . '`';
+			$this->valueHandler->updateEntityVersionValues($entity, $fetchedDatetimeValues);
 		}
 
 		/**
@@ -174,7 +164,7 @@ protected function buildVersionSetClause(array $versionColumns, array &$params):
 
 			// Process each version column according to its type
 			foreach ($versionColumns as $property => $versionColumn) {
-				$columnName = $this->escapeIdentifier($versionColumn['name']);
+				$columnName = $this->valueHandler->escapeIdentifier($versionColumn['name']);
 
 				switch($versionColumn['column']->getType()) {
 					case 'integer':
@@ -215,7 +205,7 @@ protected function buildFieldsSetClause(array $changedFields, array &$params): a
 			$setClauseParts = [];
 			foreach ($changedFields as $columnName => $value) {
 				$paramName = "field_{$columnName}";
-				$setClauseParts[] = $this->escapeIdentifier($columnName) . "=:{$paramName}";
+				$setClauseParts[] = $this->valueHandler->escapeIdentifier($columnName) . "=:{$paramName}";
 				$params[$paramName] = $value;
 			}
 
@@ -239,7 +229,7 @@ protected function buildWhereClause(array $primaryKeyColumnNames, array $primary
 			// This includes primary key columns to identify the record
 			foreach ($primaryKeyColumnNames as $columnName) {
 				$paramName = "pk_{$columnName}";
-				$whereClauseParts[] = $this->escapeIdentifier($columnName) . "=:{$paramName}";
+				$whereClauseParts[] = $this->valueHandler->escapeIdentifier($columnName) . "=:{$paramName}";
 				$params[$paramName] = $primaryKeyValues[$columnName];
 			}
 
@@ -249,7 +239,7 @@ protected function buildWhereClause(array $primaryKeyColumnNames, array $primary
 			foreach ($versionColumns as $property => $versionColumn) {
 				$columnName = $versionColumn['name'];
 				$paramName = "where_version_{$columnName}";
-				$whereClauseParts[] = $this->escapeIdentifier($columnName) . "=:{$paramName}";
+				$whereClauseParts[] = $this->valueHandler->escapeIdentifier($columnName) . "=:{$paramName}";
 
 				// Use the original version value from our snapshot
 				$params[$paramName] = $originalData[$columnName];
@@ -258,66 +248,4 @@ protected function buildWhereClause(array $primaryKeyColumnNames, array $primary
 			// Combine all WHERE clause parts
 			return implode(" AND ", $whereClauseParts);
 		}
-		
-		/**
-		 * Fetches version values back from the database after update
-		 * Required to ensure in-memory entity matches database state exactly
-		 * @param string $tableName Escaped table name
-		 * @param array $versionColumns All version column metadata
-		 * @param array $primaryKeyColumnNames Primary key column names
-		 * @param array $primaryKeyValues Primary key values
-		 * @return array Fetched version values as property_name => value pairs
-		 */
-		protected function fetchUpdatedVersionValues(string $tableName, array $versionColumns, array $primaryKeyColumnNames, array $primaryKeyValues): array {
-			// Do nothing when no version columns exist
-			if (empty($versionColumns)) {
-				return [];
-			}
-			
-			// Build a SELECT query to retrieve all version columns
-			$selectColumns = array_map(fn($vc) => $this->escapeIdentifier($vc['name']), $versionColumns);
-			
-			// Build WHERE clause using only primary keys to identify the row we just updated
-			$whereClauseParts = [];
-			$selectParams = [];
-			
-			foreach ($primaryKeyColumnNames as $columnName) {
-				$paramName = "pk_{$columnName}";
-				$whereClauseParts[] = $this->escapeIdentifier($columnName) . "=:{$paramName}";
-				$selectParams[$paramName] = $primaryKeyValues[$columnName];
-			}
-			
-			// Build select query
-			$selectSql = "SELECT " . implode(", ", $selectColumns) . " FROM {$tableName} WHERE " . implode(" AND ", $whereClauseParts);
-			
-			// Execute select query
-			$result = $this->connection->Execute($selectSql, $selectParams);
-			
-			// Collect fetched datetime values
-			if (!$result || !($row = $result->fetchAssoc())) {
-				return [];
-			}
-			
-			return array_map(function ($vc) use ($row) {
-				return $row[$vc['name']];
-			}, $versionColumns);
-		}
-		
-		/**
-		 * Updates the entity with new version values from the database
-		 * @param object $entity The entity to update
-		 * @param array $fetchedValues Fetched version values as property_name => value pairs
-		 * @return void
-		 */
-		protected function updateEntityVersionValues(object $entity, array $fetchedValues): void {
-			if (empty($fetchedValues)) {
-				return;
-			}
-			
-			$annotations = $this->entityStore->getAnnotations($entity, Column::class);
-			foreach ($fetchedValues as $property => $newValue) {
-				$normalizedValue = $this->unitOfWork->getSerializer()->normalizeValue($annotations[$property], $newValue);
-				$this->propertyHandler->set($entity, $property, $normalizedValue);
-			}
-		}
 	}