tonyair/silverstripe-framework
1
0
Fork 0
mirror of https://github.com/silverstripe/silverstripe-framework synced 2024-09-28 20:29:15 +02:00
Code Issues Projects Releases Wiki Activity

API Rename _versions table to _Versions

Browse Source 
API Support case-sensitive changes to tables
Fixes #2365
This commit is contained in:
Damian Mooyman 2016-10-20 14:49:22 +13:00
parent 02af9b83d9
commit ea6851fd70
10 changed files with 161 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
ORM/Connect/DBSchemaManager.php
View File

@ -22,10 +22,18 @@ abstract class DBSchemaManager {
* data corruption in tables, you can disable this behaviour and handle it
* outside of this class, e.g. through a nightly system task with extended logging capabilities.
*
* @var boolean
* @var bool
*/
private static $check_and_repair_on_build = true;
/**
* Check if tables should be renamed in a case-sensitive fashion.
* Note: This should still work even on case-insensitive databases.
*
* @var bool
*/
private static $fix_table_case_on_build = true;
/**
* Instance of the database controller this schema belongs to
*
@ -151,8 +159,8 @@ abstract class DBSchemaManager {
}
}
} finally {
$this->schemaUpdateTransaction = null;
$this->schemaIsUpdating = false;
$this->schemaUpdateTransaction = null;
$this->schemaIsUpdating = false;
}
}
@ -305,7 +313,10 @@ abstract class DBSchemaManager {
$this->transCreateTable($table, $options, $extensions);
$this->alterationMessage("Table $table: created", "created");
} else {
if (Config::inst()->get('SilverStripe\ORM\Connect\DBSchemaManager', 'check_and_repair_on_build')) {
if (Config::inst()->get(static::class, 'fix_table_case_on_build')) {
$this->fixTableCase($table);
}
if (Config::inst()->get(static::class, 'check_and_repair_on_build')) {
$this->checkAndRepairTable($table);
}
@ -778,6 +789,37 @@ abstract class DBSchemaManager {
*/
abstract public function checkAndRepairTable($tableName);
/**
* Ensure the given table has the correct case
*
* @param string $tableName Name of table in desired case
*/
public function fixTableCase($tableName)
{
// Check if table exists
$tables = $this->tableList();
if (!array_key_exists(strtolower($tableName), $tables)) {
return;
}
// Check if case differs
$currentName = $tables[strtolower($tableName)];
if ($currentName === $tableName) {
return;
}
$this->alterationMessage(
"Table $tableName: renamed from $currentName",
"repaired"
);
// Rename via temp table to avoid case-sensitivity issues
$tempTable = "__TEMP__{$tableName}";
$this->renameTable($currentName, $tempTable);
$this->renameTable($tempTable, $tableName);
}
/**
* Returns the values of the given enum field
*

22
ORM/Connect/MySQLSchemaManager.php
View File

@ -144,24 +144,14 @@ class MySQLSchemaManager extends DBSchemaManager {
}
// Perform check
if (!$this->runTableCheckCommand("CHECK TABLE \"$tableName\"")) {
if ($this->runTableCheckCommand("CHECK TABLE \"" . strtolower($tableName) . "\"")) {
$this->alterationMessage(
"Table $tableName: renamed from lowercase",
"repaired"
);
$this->renameTable(strtolower($tableName), $tableName);
return true;
}
$this->alterationMessage(
"Table $tableName: repaired",
"repaired"
);
return $this->runTableCheckCommand("REPAIR TABLE \"$tableName\" USE_FRM");
} else {
if ($this->runTableCheckCommand("CHECK TABLE \"$tableName\"")) {
return true;
}
$this->alterationMessage(
"Table $tableName: repaired",
"repaired"
);
return $this->runTableCheckCommand("REPAIR TABLE \"$tableName\" USE_FRM");
}
/**

2
ORM/DataObjectSchema.php
View File

@ -226,7 +226,7 @@ class DataObjectSchema {
return $class;
}
// If there is no class for this table, strip table modifiers (e.g. _Live / _versions)
// If there is no class for this table, strip table modifiers (e.g. _Live / _Versions)
// from the end and re-attempt a search.
if(preg_match('/^(?<class>.+)(_[^_]+)$/i', $table, $matches)) {
$table = $matches['class'];

2
ORM/FieldType/DBClassName.php
View File

@ -119,7 +119,7 @@ class DBClassName extends DBEnum {
*/
public function getEnum() {
$classNames = ClassInfo::subclassesFor($this->getBaseClass());
unset($classNames['SilverStripe\ORM\DataObject']);
unset($classNames[DataObject::class]);
return $classNames;
}

112
ORM/Versioning/Versioned.php
View File

@ -103,7 +103,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
/**
* Additional database columns for the new
* "_versions" table. Used in {@link augmentDatabase()}
* "_Versions" table. Used in {@link augmentDatabase()}
* and all Versioned calls extending or creating
* SELECT statements.
*
@ -135,7 +135,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
/**
* Additional database indexes for the new
* "_versions" table. Used in {@link augmentDatabase()}.
* "_Versions" table. Used in {@link augmentDatabase()}.
*
* @var array $indexes_for_versions_table
*/
@ -298,7 +298,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
}
// Build query
$table = "\"{$baseTable}_versions\"";
$table = "\"{$baseTable}_Versions\"";
$query = SQLSelect::create('"LastEdited"', $table)
->addWhere([
"{$table}.\"RecordID\"" => $id,
@ -428,26 +428,26 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
// Make sure join includes version as well
$query->setJoinFilter(
$alias,
"\"{$alias}_versions\".\"RecordID\" = \"{$baseTable}_versions\".\"RecordID\""
. " AND \"{$alias}_versions\".\"Version\" = \"{$baseTable}_versions\".\"Version\""
"\"{$alias}_Versions\".\"RecordID\" = \"{$baseTable}_Versions\".\"RecordID\""
. " AND \"{$alias}_Versions\".\"Version\" = \"{$baseTable}_Versions\".\"Version\""
);
}
$query->renameTable($alias, $alias . '_versions');
$query->renameTable($alias, $alias . '_Versions');
}
// Add all <basetable>_versions columns
foreach(Config::inst()->get('SilverStripe\ORM\Versioning\Versioned', 'db_for_versions_table') as $name => $type) {
$query->selectField(sprintf('"%s_versions"."%s"', $baseTable, $name), $name);
// Add all <basetable>_Versions columns
foreach(Config::inst()->get(static::class, 'db_for_versions_table') as $name => $type) {
$query->selectField(sprintf('"%s_Versions"."%s"', $baseTable, $name), $name);
}
// Alias the record ID as the row ID, and ensure ID filters are aliased correctly
$query->selectField("\"{$baseTable}_versions\".\"RecordID\"", "ID");
$query->replaceText("\"{$baseTable}_versions\".\"ID\"", "\"{$baseTable}_versions\".\"RecordID\"");
$query->selectField("\"{$baseTable}_Versions\".\"RecordID\"", "ID");
$query->replaceText("\"{$baseTable}_Versions\".\"ID\"", "\"{$baseTable}_Versions\".\"RecordID\"");
// However, if doing count, undo rewrite of "ID" column
$query->replaceText(
"count(DISTINCT \"{$baseTable}_versions\".\"RecordID\")",
"count(DISTINCT \"{$baseTable}_versions\".\"ID\")"
"count(DISTINCT \"{$baseTable}_Versions\".\"RecordID\")",
"count(DISTINCT \"{$baseTable}_Versions\".\"ID\")"
);
// Add additional versioning filters
@ -459,16 +459,16 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
}
// Link to the version archived on that date
$query->addWhere([
"\"{$baseTable}_versions\".\"Version\" IN
"\"{$baseTable}_Versions\".\"Version\" IN
(SELECT LatestVersion FROM
(SELECT
\"{$baseTable}_versions\".\"RecordID\",
MAX(\"{$baseTable}_versions\".\"Version\") AS LatestVersion
FROM \"{$baseTable}_versions\"
WHERE \"{$baseTable}_versions\".\"LastEdited\" <= ?
GROUP BY \"{$baseTable}_versions\".\"RecordID\"
) AS \"{$baseTable}_versions_latest\"
WHERE \"{$baseTable}_versions_latest\".\"RecordID\" = \"{$baseTable}_versions\".\"RecordID\"
\"{$baseTable}_Versions\".\"RecordID\",
MAX(\"{$baseTable}_Versions\".\"Version\") AS LatestVersion
FROM \"{$baseTable}_Versions\"
WHERE \"{$baseTable}_Versions\".\"LastEdited\" <= ?
GROUP BY \"{$baseTable}_Versions\".\"RecordID\"
) AS \"{$baseTable}_Versions_Latest\"
WHERE \"{$baseTable}_Versions_Latest\".\"RecordID\" = \"{$baseTable}_Versions\".\"RecordID\"
)" => $date
]);
break;
@ -477,15 +477,15 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
// Return latest version instances, regardless of whether they are on a particular stage
// This provides "show all, including deleted" functonality
$query->addWhere(
"\"{$baseTable}_versions\".\"Version\" IN
"\"{$baseTable}_Versions\".\"Version\" IN
(SELECT LatestVersion FROM
(SELECT
\"{$baseTable}_versions\".\"RecordID\",
MAX(\"{$baseTable}_versions\".\"Version\") AS LatestVersion
FROM \"{$baseTable}_versions\"
GROUP BY \"{$baseTable}_versions\".\"RecordID\"
) AS \"{$baseTable}_versions_latest\"
WHERE \"{$baseTable}_versions_latest\".\"RecordID\" = \"{$baseTable}_versions\".\"RecordID\"
\"{$baseTable}_Versions\".\"RecordID\",
MAX(\"{$baseTable}_Versions\".\"Version\") AS LatestVersion
FROM \"{$baseTable}_Versions\"
GROUP BY \"{$baseTable}_Versions\".\"RecordID\"
) AS \"{$baseTable}_Versions_Latest\"
WHERE \"{$baseTable}_Versions_Latest\".\"RecordID\" = \"{$baseTable}_Versions\".\"RecordID\"
)"
);
break;
@ -497,14 +497,14 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
throw new InvalidArgumentException("Invalid version");
}
$query->addWhere([
"\"{$baseTable}_versions\".\"Version\"" => $version
"\"{$baseTable}_Versions\".\"Version\"" => $version
]);
break;
}
case 'all_versions':
default: {
// If all versions are requested, ensure that records are sorted by this field
$query->addOrderBy(sprintf('"%s_versions"."%s"', $baseTable, 'Version'));
$query->addOrderBy(sprintf('"%s_Versions"."%s"', $baseTable, 'Version'));
break;
}
}
@ -556,7 +556,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
// The VersionedMode local variable ensures that this decorator only applies to
// queries that have originated from the Versioned object, and have the Versioned
// metadata set on the query object. This prevents regular queries from
// accidentally querying the *_versions tables.
// accidentally querying the *_Versions tables.
$versionedMode = $dataObject->getSourceQueryParam('Versioned.mode');
$modesToAllowVersioning = array('all_versions', 'latest_versions', 'archive', 'version');
if(
@ -634,17 +634,17 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
DB::require_table($liveTable, $fields, $indexes, false, $options);
}
// Build _versions table
// Build _Versions table
//Unique indexes will not work on versioned tables, so we'll convert them to standard indexes:
$nonUniqueIndexes = $this->uniqueToIndex($indexes);
if($isRootClass) {
// Create table for all versions
$versionFields = array_merge(
Config::inst()->get('SilverStripe\ORM\Versioning\Versioned', 'db_for_versions_table'),
Config::inst()->get(static::class, 'db_for_versions_table'),
(array)$fields
);
$versionIndexes = array_merge(
Config::inst()->get('SilverStripe\ORM\Versioning\Versioned', 'indexes_for_versions_table'),
Config::inst()->get(static::class, 'indexes_for_versions_table'),
(array)$nonUniqueIndexes
);
} else {
@ -667,12 +667,12 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
}
// Cleanup any orphans
$this->cleanupVersionedOrphans("{$suffixBaseTable}_versions", "{$suffixTable}_versions");
$this->cleanupVersionedOrphans("{$suffixBaseTable}_Versions", "{$suffixTable}_Versions");
// Build versions table
DB::require_table("{$suffixTable}_versions", $versionFields, $versionIndexes, true, $options);
DB::require_table("{$suffixTable}_Versions", $versionFields, $versionIndexes, true, $options);
} else {
DB::dont_require_table("{$suffixTable}_versions");
DB::dont_require_table("{$suffixTable}_Versions");
if($this->hasStages()) {
$liveTable = $this->stageTable($suffixTable, static::LIVE);
DB::dont_require_table($liveTable);
@ -682,7 +682,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
}
/**
* Cleanup orphaned records in the _versions table
* Cleanup orphaned records in the _Versions table
*
* @param string $baseTable base table to use as authoritative source of records
* @param string $childTable Sub-table to clean orphans from
@ -766,7 +766,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$baseDataClass = $schema->baseDataClass($class);
$baseDataTable = $schema->tableName($baseDataClass);
// Set up a new entry in (table)_versions
// Set up a new entry in (table)_Versions
$newManipulation = array(
"command" => "insert",
"fields" => isset($manipulation[$table]['fields']) ? $manipulation[$table]['fields'] : [],
@ -798,7 +798,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$nextVersion = 0;
if($recordID) {
$nextVersion = DB::prepared_query("SELECT MAX(\"Version\") + 1
FROM \"{$baseDataTable}_versions\" WHERE \"RecordID\" = ?",
FROM \"{$baseDataTable}_Versions\" WHERE \"RecordID\" = ?",
array($recordID)
)->value();
}
@ -813,9 +813,9 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$manipulation[$table]['fields']['Version'] = $nextVersion;
}
// Update _versions table manipulation
// Update _Versions table manipulation
$newManipulation['fields']['Version'] = $nextVersion;
$manipulation["{$table}_versions"] = $newManipulation;
$manipulation["{$table}_Versions"] = $newManipulation;
}
/**
@ -1024,7 +1024,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$lookup = array();
foreach(ClassInfo::subclassesFor('SilverStripe\ORM\DataObject') as $class) {
// Ensure this class is versioned
if(!Object::has_extension($class, 'SilverStripe\ORM\Versioning\Versioned')) {
if(!Object::has_extension($class, static::class)) {
continue;
}
@ -1378,7 +1378,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
/**
* Determine if a class is supporting the Versioned extensions (e.g.
* $table_versions does exists).
* $table_Versions does exists).
*
* @param string $class Class name
* @return boolean
@ -1714,7 +1714,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
// Mark this version as having been published at some stage
$publisherID = isset(Member::currentUser()->ID) ? Member::currentUser()->ID : 0;
$extTable = $this->extendWithSuffix($baseTable);
DB::prepared_query("UPDATE \"{$extTable}_versions\"
DB::prepared_query("UPDATE \"{$extTable}_Versions\"
SET \"WasPublished\" = ?, \"PublisherID\" = ?
WHERE \"RecordID\" = ? AND \"Version\" = ?",
array(1, $publisherID, $from->ID, $from->Version)
@ -1827,23 +1827,23 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$baseTable = str_replace('"','',$tableJoin);
} elseif(is_string($tableJoin) && substr($tableJoin,0,5) != 'INNER') {
$query->setFrom(array(
$table => "LEFT JOIN \"$table\" ON \"$table\".\"RecordID\"=\"{$baseTable}_versions\".\"RecordID\""
. " AND \"$table\".\"Version\" = \"{$baseTable}_versions\".\"Version\""
$table => "LEFT JOIN \"$table\" ON \"$table\".\"RecordID\"=\"{$baseTable}_Versions\".\"RecordID\""
. " AND \"$table\".\"Version\" = \"{$baseTable}_Versions\".\"Version\""
));
}
$query->renameTable($table, $table . '_versions');
$query->renameTable($table, $table . '_Versions');
}
// Add all <basetable>_versions columns
foreach(Config::inst()->get('SilverStripe\ORM\Versioning\Versioned', 'db_for_versions_table') as $name => $type) {
$query->selectField(sprintf('"%s_versions"."%s"', $baseTable, $name), $name);
// Add all <basetable>_Versions columns
foreach(Config::inst()->get(static::class, 'db_for_versions_table') as $name => $type) {
$query->selectField(sprintf('"%s_Versions"."%s"', $baseTable, $name), $name);
}
$query->addWhere(array(
"\"{$baseTable}_versions\".\"RecordID\" = ?" => $owner->ID
"\"{$baseTable}_Versions\".\"RecordID\" = ?" => $owner->ID
));
$query->setOrderBy(($sort) ? $sort
: "\"{$baseTable}_versions\".\"LastEdited\" DESC, \"{$baseTable}_versions\".\"Version\" DESC");
: "\"{$baseTable}_Versions\".\"LastEdited\" DESC, \"{$baseTable}_Versions\".\"Version\" DESC");
$records = $query->execute();
$versions = new ArrayList();
@ -2122,7 +2122,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
* @param array $idList
*/
public static function prepopulate_versionnumber_cache($class, $stage, $idList = null) {
if (!Config::inst()->get('SilverStripe\ORM\Versioning\Versioned', 'prepopulate_versionnumber_cache')) {
if (!Config::inst()->get(static::class, 'prepopulate_versionnumber_cache')) {
return;
}
$filter = "";
@ -2363,7 +2363,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
/**
* Return the equivalent of a DataList::create() call, querying the latest
* version of each record stored in the (class)_versions tables.
* version of each record stored in the (class)_Versions tables.
*
* In particular, this will query deleted records as well as active ones.
*
@ -2502,7 +2502,7 @@ class Versioned extends DataExtension implements TemplateGlobalProvider {
$itemKey = get_class($item) . '/' . $item->ID;
// Write if saved, versioned, and not already added
if ($item->isInDB() && $item->has_extension('SilverStripe\ORM\Versioning\Versioned') && !isset($list[$itemKey])) {
if ($item->isInDB() && $item->has_extension(static::class) && !isset($list[$itemKey])) {
$list[$itemKey] = $item;
$added[$itemKey] = $item;
}

2
docs/en/04_Changelogs/4.0.0.md
View File

@ -897,6 +897,8 @@ A very small number of methods were chosen for deprecation, and will be removed
* Any writes to versioned dataobjects (in either Draft or Live) will always write to the draft
(main) table as a source of truth. This means that records created in Live mode will always be
available to the CMS and in draft mode.
* `_versions` suffixed tables are now renamed to `_Versions`. This fix will be automatically
applied during dev/build.
* A lot of standard versioned API has been refactored from `SiteTree` into `Versioned` extension.
* All versioned DataObjects have `canPublish()`, `canArchive()`, `canUnpublish()` permission checks
* All versioned Dataobjects have `doPublish()`, `doArchive()`, `doPublish()`, and `doUnpublish()` actions.

2
tests/model/DBClassNameTest.php
View File

@ -86,7 +86,7 @@ class DBClassNameTest extends SapphireTest {
// Implicit table
$field4 = new DBClassName('MyClass');
$field4->setTable('DBClassNameTest_ObjectSubClass_versions');
$field4->setTable('DBClassNameTest_ObjectSubClass_Versions');
$this->assertEquals('DBClassNameTest_Object', $field4->getBaseClass());
$this->assertEquals('DBClassNameTest_Object', $field4->getDefault());

4
tests/model/DataObjectLazyLoadingTest.php
View File

@ -376,12 +376,12 @@ class DataObjectLazyLoadingTest extends SapphireTest {
// Force inconsistent state to test behaviour (shouldn't select from *_versions)
DB::query(sprintf(
"UPDATE \"VersionedLazy_DataObject_versions\" SET \"PageName\" = 'versioned-value' " .
"UPDATE \"VersionedLazy_DataObject_Versions\" SET \"PageName\" = 'versioned-value' " .
"WHERE \"RecordID\" = %d",
$obj1ID
));
DB::query(sprintf(
"UPDATE \"VersionedLazySub_DataObject_versions\" SET \"ExtraField\" = 'versioned-value' " .
"UPDATE \"VersionedLazySub_DataObject_Versions\" SET \"ExtraField\" = 'versioned-value' " .
"WHERE \"RecordID\" = %d",
$obj1ID
));

33
tests/model/DataObjectSchemaGenerationTest.php
View File

@ -27,6 +27,39 @@ class DataObjectSchemaGenerationTest extends SapphireTest {
parent::setUpOnce();
}
public function testTableCaseFixed() {
DB::quiet();
// Modify table case
DB::get_schema()->renameTable(
'DataObjectSchemaGenerationTest_DO',
'__TEMP__DataOBJECTSchemaGenerationTest_do'
);
DB::get_schema()->renameTable(
'__TEMP__DataOBJECTSchemaGenerationTest_do',
'DataOBJECTSchemaGenerationTest_do'
);
// Check table
$tables = DB::table_list();
$this->assertEquals(
'DataOBJECTSchemaGenerationTest_do',
$tables['dataobjectschemagenerationtest_do']
);
// Rebuild table
DB::get_schema()->schemaUpdate(function() {
DataObjectSchemaGenerationTest_DO::singleton()->requireTable();
});
// Check table
$tables = DB::table_list();
$this->assertEquals(
'DataObjectSchemaGenerationTest_DO',
$tables['dataobjectschemagenerationtest_do']
);
}
/**
* Check that once a schema has been generated, then it doesn't need any more updating
*/

26
tests/model/VersionedTest.php
View File

@ -52,8 +52,8 @@ class VersionedTest extends SapphireTest {
$tableExpectations = array(
'VersionedTest_WithIndexes' =>
array('value' => true, 'message' => 'Unique indexes are unique in main table'),
'VersionedTest_WithIndexes_versions' =>
array('value' => false, 'message' => 'Unique indexes are no longer unique in _versions table'),
'VersionedTest_WithIndexes_Versions' =>
array('value' => false, 'message' => 'Unique indexes are no longer unique in _Versions table'),
'VersionedTest_WithIndexes_Live' =>
array('value' => true, 'message' => 'Unique indexes are unique in _Live table'),
);
@ -93,22 +93,22 @@ class VersionedTest extends SapphireTest {
$obj->write();
$obj->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);
$versions = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_versions\""
$versions = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_Versions\""
. " WHERE \"RecordID\" = '$obj->ID'")->value();
$this->assertGreaterThan(0, $versions, 'At least 1 version exists in the history of the page');
// Force orphaning of all versions created earlier, only on parent record.
// The child versiones table should still have the correct relationship
DB::query("DELETE FROM \"VersionedTest_DataObject_versions\" WHERE \"RecordID\" = $obj->ID");
DB::query("DELETE FROM \"VersionedTest_DataObject_Versions\" WHERE \"RecordID\" = $obj->ID");
// insert a record with no primary key (ID)
DB::query("INSERT INTO \"VersionedTest_DataObject_versions\" (\"RecordID\") VALUES ($obj->ID)");
DB::query("INSERT INTO \"VersionedTest_DataObject_Versions\" (\"RecordID\") VALUES ($obj->ID)");
// run the script which should clean that up
$obj->augmentDatabase();
$versions = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_versions\""
$versions = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_Versions\""
. " WHERE \"RecordID\" = '$obj->ID'")->value();
$this->assertEquals(0, $versions, 'Orphaned versions on child tables are removed');
@ -116,11 +116,11 @@ class VersionedTest extends SapphireTest {
$obj->write();
$obj->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);
$count = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_versions\""
$count = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_Versions\""
. " WHERE \"RecordID\" = '$obj->ID'")->value();
$obj->augmentDatabase();
$count2 = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_versions\""
$count2 = DB::query("SELECT COUNT(*) FROM \"VersionedTest_Subclass_Versions\""
. " WHERE \"RecordID\" = '$obj->ID'")->value();
$this->assertEquals($count, $count2);
@ -309,15 +309,15 @@ class VersionedTest extends SapphireTest {
$this->assertEquals('orig', $page1->Content, 'Copies the content from the old version');
// check db entries
$version = DB::prepared_query("SELECT MAX(\"Version\") FROM \"VersionedTest_DataObject_versions\" WHERE \"RecordID\" = ?",
$version = DB::prepared_query("SELECT MAX(\"Version\") FROM \"VersionedTest_DataObject_Versions\" WHERE \"RecordID\" = ?",
array($page1->ID)
)->value();
$this->assertEquals($page1->Version, $version, 'Correct entry in VersionedTest_DataObject_versions');
$this->assertEquals($page1->Version, $version, 'Correct entry in VersionedTest_DataObject_Versions');
$version = DB::prepared_query("SELECT MAX(\"Version\") FROM \"VersionedTest_AnotherSubclass_versions\" WHERE \"RecordID\" = ?",
$version = DB::prepared_query("SELECT MAX(\"Version\") FROM \"VersionedTest_AnotherSubclass_Versions\" WHERE \"RecordID\" = ?",
array($page1->ID)
)->value();
$this->assertEquals($page1->Version, $version, 'Correct entry in VersionedTest_AnotherSubclass_versions');
$this->assertEquals($page1->Version, $version, 'Correct entry in VersionedTest_AnotherSubclass_Versions');
}
public function testDeleteFromStage() {
@ -884,7 +884,7 @@ class VersionedTest extends SapphireTest {
protected function assertRecordHasLatestVersion($record, $version) {
foreach(ClassInfo::ancestry(get_class($record), true) as $table) {
$versionForClass = DB::prepared_query(
$sql = "SELECT MAX(\"Version\") FROM \"{$table}_versions\" WHERE \"RecordID\" = ?",
$sql = "SELECT MAX(\"Version\") FROM \"{$table}_Versions\" WHERE \"RecordID\" = ?",
array($record->ID)
)->value();
$this->assertEquals($version, $versionForClass, "That the table $table has the latest version $version");