void Database::UpdateStatsWithOid(const oid_t table_oid) const {
LOG_INFO("Update table(%lu)'s stats in Database(%lu)", table_oid,
database_oid);
auto table = GetTableWithOid(table_oid);
bridge::Bridge::SetNumberOfTuples(table_oid, table->GetNumberOfTuples());
for (oid_t index_offset = 0; index_offset < table->GetIndexCount();
index_offset++) {
auto index = table->GetIndex(index_offset);
bridge::Bridge::SetNumberOfTuples(index->GetOid(),
index->GetNumberOfTuples());
}
}
TEST_F(LoggingTests, BasicDeleteTest) {
auto recovery_table = ExecutorTestsUtil::CreateTable(1024);
auto &manager = catalog::Manager::GetInstance();
storage::Database db(DEFAULT_DB_ID);
manager.AddDatabase(&db);
db.AddTable(recovery_table);
EXPECT_EQ(recovery_table->GetNumberOfTuples(), 0);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 1);
logging::WriteAheadFrontendLogger fel(true);
cid_t test_commit_id = 10;
auto curr_rec = new logging::TupleRecord(
LOGRECORD_TYPE_TUPLE_UPDATE, test_commit_id, recovery_table->GetOid(),
INVALID_ITEMPOINTER, ItemPointer(100, 4), nullptr, DEFAULT_DB_ID);
fel.DeleteTuple(curr_rec);
delete curr_rec;
auto tg_header = recovery_table->GetTileGroupById(100)->GetHeader();
EXPECT_EQ(tg_header->GetEndCommitId(4), test_commit_id);
// EXPECT_EQ(recovery_table->GetNumberOfTuples(), 1);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 2);
}
TEST_F(DEMImageNormals_test, NormalsAreNormalized)
{
auto demNormalFilter = vtkSmartPointer<DEMImageNormals>::New();
demNormalFilter->SetCoordinatesUnitScale(1.0);
demNormalFilter->SetElevationUnitScale(1.0);
demNormalFilter->SetInputData(dem);
ASSERT_TRUE(demNormalFilter->GetExecutive()->Update());
auto normals = demNormalFilter->GetOutput()->GetPointData()->GetNormals();
ASSERT_TRUE(normals);
ASSERT_EQ(dem->GetNumberOfPoints(), normals->GetNumberOfTuples());
for (vtkIdType i = 0; i < normals->GetNumberOfTuples(); ++i)
{
vtkVector3d normal;
normals->GetTuple(i, normal.GetData());
ASSERT_FLOAT_EQ(1.f, static_cast<float>(normal.Norm()));
}
}
TEST_F(LoggingTests, BasicUpdateTest) {
auto recovery_table = ExecutorTestsUtil::CreateTable(1024);
auto &manager = catalog::Manager::GetInstance();
storage::Database db(DEFAULT_DB_ID);
manager.AddDatabase(&db);
db.AddTable(recovery_table);
auto tuples = BuildLoggingTuples(recovery_table, 1, false, false);
EXPECT_EQ(recovery_table->GetNumberOfTuples(), 0);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 1);
EXPECT_EQ(tuples.size(), 1);
logging::WriteAheadFrontendLogger fel(true);
// auto bel = logging::WriteAheadBackendLogger::GetInstance();
cid_t test_commit_id = 10;
Value val0 = tuples[0]->GetValue(0);
Value val1 = tuples[0]->GetValue(1);
Value val2 = tuples[0]->GetValue(2);
Value val3 = tuples[0]->GetValue(3);
auto curr_rec = new logging::TupleRecord(
LOGRECORD_TYPE_TUPLE_UPDATE, test_commit_id, recovery_table->GetOid(),
ItemPointer(100, 5), ItemPointer(100, 4), tuples[0], DEFAULT_DB_ID);
curr_rec->SetTuple(tuples[0]);
fel.UpdateTuple(curr_rec);
delete curr_rec;
auto tg_header = recovery_table->GetTileGroupById(100)->GetHeader();
EXPECT_TRUE(tg_header->GetBeginCommitId(5) <= test_commit_id);
EXPECT_EQ(tg_header->GetEndCommitId(5), MAX_CID);
EXPECT_EQ(tg_header->GetEndCommitId(4), test_commit_id);
EXPECT_TRUE(
val0.Compare(recovery_table->GetTileGroupById(100)->GetValue(5, 0)) == 0);
EXPECT_TRUE(
val1.Compare(recovery_table->GetTileGroupById(100)->GetValue(5, 1)) == 0);
EXPECT_TRUE(
val2.Compare(recovery_table->GetTileGroupById(100)->GetValue(5, 2)) == 0);
EXPECT_TRUE(
val3.Compare(recovery_table->GetTileGroupById(100)->GetValue(5, 3)) == 0);
EXPECT_EQ(recovery_table->GetNumberOfTuples(), 0);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 2);
}
TEST_F(ArrayChangeInformationFilter_test, vtkAssignAttribute_CorrectNumberOfComponentsPassedDownstream)
{
inAttr->SetNumberOfComponents(3);
inAttr->SetNumberOfTuples(17);
for (vtkIdType i = 0; i < inAttr->GetNumberOfValues(); ++i)
{
inAttr->SetValue(i, static_cast<float>(i));
}
auto inImage = vtkSmartPointer<vtkImageData>::New();
inImage->GetPointData()->SetScalars(inAttr);
inImage->SetExtent(0, 0, 2, 18, 3, 3);
auto infoSource = vtkSmartPointer<InformationSource>::New();
infoSource->SetOutput(inImage);
vtkDataObject::SetActiveAttributeInfo(infoSource->GetOutInfo(),
vtkDataObject::FIELD_ASSOCIATION_POINTS,
vtkDataSetAttributes::SCALARS,
inAttr->GetName(),
inAttr->GetDataType(),
inAttr->GetNumberOfComponents(),
static_cast<int>(inAttr->GetNumberOfTuples()));
filter->SetAttributeLocation(ArrayChangeInformationFilter::POINT_DATA);
filter->SetAttributeType(vtkDataSetAttributes::SCALARS);
filter->SetInputConnection(infoSource->GetOutputPort());
filter->EnableRenameOff();
filter->EnableSetUnitOff();
auto assignToVectors = vtkSmartPointer<vtkAssignAttribute>::New();
assignToVectors->SetInputConnection(filter->GetOutputPort());
assignToVectors->Assign(vtkDataSetAttributes::SCALARS, vtkDataSetAttributes::VECTORS,
vtkAssignAttribute::POINT_DATA);
auto reassignScalars = vtkSmartPointer<vtkAssignAttribute>::New();
reassignScalars->SetInputConnection(assignToVectors->GetOutputPort());
reassignScalars->Assign(vtkDataSetAttributes::VECTORS, vtkDataSetAttributes::SCALARS,
vtkAssignAttribute::POINT_DATA);
auto normalize = vtkSmartPointer<vtkImageNormalize>::New();
normalize->SetInputConnection(reassignScalars->GetOutputPort());
normalize->SetEnableSMP(false);
normalize->SetNumberOfThreads(1);
// before patching (VTK 7.1+) vtkAssignAttribute, this would cause segmentation faults
normalize->Update();
auto outImg = normalize->GetOutput();
auto outScalars = outImg->GetPointData()->GetScalars();
ASSERT_EQ(inAttr->GetNumberOfComponents(), outScalars->GetNumberOfComponents());
ASSERT_EQ(inAttr->GetNumberOfTuples(), outScalars->GetNumberOfTuples());
}
int AssignPointAttributeToCoordinatesFilter::RequestData(
vtkInformation * /*request*/,
vtkInformationVector ** inputVector,
vtkInformationVector * outputVector)
{
auto inData = vtkPointSet::SafeDownCast(inputVector[0]->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
auto outData = vtkPointSet::SafeDownCast(outputVector->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
auto previousPointCoords = inData->GetPoints()->GetData();
vtkDataArray * pointsToAssign = nullptr;
if (!this->AttributeArrayToAssign.empty())
{
auto newPoints = inData->GetPointData()->GetArray(this->AttributeArrayToAssign.c_str());
if (!newPoints)
{
vtkErrorMacro("Array to assign not found in input data: " + this->AttributeArrayToAssign);
return 0;
}
if (newPoints->GetNumberOfComponents() != 3
|| newPoints->GetNumberOfTuples() != inData->GetNumberOfPoints())
{
vtkErrorMacro("Component/Tuple count mismatching in selected data array: " + this->AttributeArrayToAssign);
return 0;
}
pointsToAssign = newPoints;
}
outData->ShallowCopy(inData);
if (pointsToAssign)
{
vtkNew<vtkPoints> newPoints;
newPoints->SetData(pointsToAssign);
outData->SetPoints(newPoints.Get());
}
// pass current point coordinates as point attribute
if (previousPointCoords)
{
outData->GetPointData()->AddArray(previousPointCoords);
}
if (auto currentCoords = pointsToAssign ? pointsToAssign : previousPointCoords)
{
outData->GetPointData()->SetActiveScalars(currentCoords->GetName());
}
return 1;
}
TEST_F(LoggingTests, OutOfOrderCommitTest) {
auto recovery_table = ExecutorTestsUtil::CreateTable(1024);
auto &manager = catalog::Manager::GetInstance();
storage::Database db(DEFAULT_DB_ID);
manager.AddDatabase(&db);
db.AddTable(recovery_table);
auto tuples = BuildLoggingTuples(recovery_table, 1, false, false);
EXPECT_EQ(recovery_table->GetNumberOfTuples(), 0);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 1);
EXPECT_EQ(tuples.size(), 1);
logging::WriteAheadFrontendLogger fel(true);
// auto bel = logging::WriteAheadBackendLogger::GetInstance();
cid_t test_commit_id = 10;
auto curr_rec = new logging::TupleRecord(
LOGRECORD_TYPE_TUPLE_UPDATE, test_commit_id + 1, recovery_table->GetOid(),
INVALID_ITEMPOINTER, ItemPointer(100, 5), nullptr, DEFAULT_DB_ID);
fel.DeleteTuple(curr_rec);
delete curr_rec;
EXPECT_EQ(recovery_table->GetTileGroupCount(), 2);
curr_rec = new logging::TupleRecord(
LOGRECORD_TYPE_TUPLE_INSERT, test_commit_id, recovery_table->GetOid(),
ItemPointer(100, 5), INVALID_ITEMPOINTER, tuples[0], DEFAULT_DB_ID);
curr_rec->SetTuple(tuples[0]);
fel.InsertTuple(curr_rec);
delete curr_rec;
auto tg_header = recovery_table->GetTileGroupById(100)->GetHeader();
EXPECT_EQ(tg_header->GetEndCommitId(5), test_commit_id + 1);
EXPECT_EQ(recovery_table->GetNumberOfTuples(), 0);
EXPECT_EQ(recovery_table->GetTileGroupCount(), 2);
}
void SetUp() override
{
dem = vtkSmartPointer<vtkImageData>::New();
dem->SetExtent(extent.data());
dem->AllocateScalars(VTK_FLOAT, 1);
dem->GetIncrements(incs.GetData());
auto elevations = dem->GetPointData()->GetScalars();
elevations->SetName("Elevations");
for (vtkIdType i = 0; i < elevations->GetNumberOfTuples(); ++i)
{
elevations->SetComponent(i, 0, 0.f);
}
dem->SetScalarComponentFromFloat(2, 3, 0, 0, 1.0);
dem->SetScalarComponentFromFloat(2, 4, 0, 0, 1.0);
dem->SetScalarComponentFromFloat(2, 5, 0, 0, 2.0);
}
TEST_F(TestVtkMeshConverter, Conversion)
{
auto mesh = std::unique_ptr<MeshLib::Mesh>(
MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtu));
ASSERT_EQ(mesh->getNNodes(), vtu->GetNumberOfPoints());
ASSERT_EQ(mesh->getNElements(), vtu->GetNumberOfCells());
ASSERT_EQ(mesh->getElement(0)->getCellType(), MeshLib::CellType::HEX8);
auto meshProperties = mesh->getProperties();
// MaterialIDs are converted to an int property
auto materialIds = meshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_TRUE(static_cast<bool>(materialIds));
auto vtkMaterialIds = vtu->GetCellData()->GetArray("MaterialIDs");
ASSERT_EQ((*materialIds).size(), vtkMaterialIds->GetNumberOfTuples());
for(std::size_t i = 0; i < (*materialIds).size(); i++)
ASSERT_EQ((*materialIds)[i], vtkMaterialIds->GetTuple1(i));
}
/**
* @brief Removes Tuples from the Array. If the size of the vector is Zero nothing is done. If the size of the
* vector is greater than or Equal to the number of Tuples then the Array is Resized to Zero. If there are
* indices that are larger than the size of the original (before erasing operations) then an error code (-100) is
* returned from the program.
* @param idxs The indices to remove
* @return error code.
*/
virtual int EraseTuples(std::vector<size_t> &idxs)
{
int err = 0;
// If nothing is to be erased just return
if(idxs.size() == 0)
{
return 0;
}
if (idxs.size() >= GetNumberOfTuples() )
{
Resize(0);
return 0;
}
// Sanity Check the Indices in the vector to make sure we are not trying to remove any indices that are
// off the end of the array and return an error code.
for(std::vector<size_t>::size_type i = 0; i < idxs.size(); ++i)
{
if (idxs[i] >= _data.size()) { return -100; }
}
std::vector<SharedVectorType> replacement(_data.size() - idxs.size());
size_t idxsIndex = 0;
size_t rIdx = 0;
for(size_t dIdx = 0; dIdx < _data.size(); ++dIdx)
{
if (dIdx != idxs[idxsIndex])
{
replacement[rIdx] = _data[dIdx];
++rIdx;
}
else
{
++idxsIndex;
if (idxsIndex == idxs.size() ) { idxsIndex--;}
}
}
_data = replacement;
return err;
}
/**
*
* @param parentId
* @return
*/
virtual int writeH5Data(hid_t parentId)
{
if (Array == NULL) { return -85648; }
return H5DataArrayWriter<T>::writeArray(parentId, GetName(), GetNumberOfTuples(), GetNumberOfComponents(), Array, getFullNameOfClass());
}
/**
* @brief Removes Tuples from the Array. If the size of the vector is Zero nothing is done. If the size of the
* vector is greater than or Equal to the number of Tuples then the Array is Resized to Zero. If there are
* indices that are larger than the size of the original (before erasing operations) then an error code (-100) is
* returned from the program.
* @param idxs The indices to remove
* @return error code.
*/
virtual int EraseTuples(std::vector<size_t> &idxs)
{
int err = 0;
// If nothing is to be erased just return
if(idxs.size() == 0)
{
return 0;
}
if (idxs.size() >= GetNumberOfTuples() )
{
Resize(0);
return 0;
}
// Sanity Check the Indices in the vector to make sure we are not trying to remove any indices that are
// off the end of the array and return an error code.
for(std::vector<size_t>::size_type i = 0; i < idxs.size(); ++i)
{
if (idxs[i] * this->NumberOfComponents > this->MaxId) { return -100; }
}
// Calculate the new size of the array to copy into
size_t newSize = (GetNumberOfTuples() - idxs.size()) * NumberOfComponents ;
T* currentSrc = this->Array;
// Create a new Array to copy into
T* newArray = (T*)malloc(newSize * sizeof(T));
// Splat AB across the array so we know if we are copying the values or not
::memset(newArray, 0xAB, newSize * sizeof(T));
// Keep the current Destination Pointer
T* currentDest = newArray;
size_t j = 0;
size_t k = 0;
// Find the first chunk to copy by walking the idxs array until we get an
// index that is NOT a continuous increment from the start
for (k = 0; k < idxs.size(); ++k)
{
if(j == idxs[k])
{
++j;
}
else
{
break;
}
}
if(k == idxs.size()) // Only front elements are being dropped
{
currentSrc = Array + (j * NumberOfComponents);
::memcpy(currentDest, currentSrc, (GetNumberOfTuples() - idxs.size()) * NumberOfComponents * sizeof(T));
_deallocate(); // We are done copying - delete the current Array
this->Size = newSize;
this->Array = newArray;
this->_ownsData = true;
this->MaxId = newSize - 1;
return 0;
}
std::vector<size_t> srcIdx(idxs.size() + 1);
std::vector<size_t> destIdx(idxs.size() + 1);
std::vector<size_t> copyElements(idxs.size() + 1);
srcIdx[0] = 0;
destIdx[0] = 0;
copyElements[0] = (idxs[0] - 0) * NumberOfComponents;
for (size_t i = 1; i < srcIdx.size(); ++i)
{
srcIdx[i] = (idxs[i - 1] + 1) * NumberOfComponents;
if(i < srcIdx.size() - 1)
{
copyElements[i] = (idxs[i] - idxs[i - 1] - 1) * NumberOfComponents;
}
else
{
copyElements[i] = (GetNumberOfTuples() - idxs[i - 1] - 1) * NumberOfComponents;
}
destIdx[i] = copyElements[i - 1] + destIdx[i - 1];
}
// Copy the data
for (size_t i = 0; i < srcIdx.size(); ++i)
{
currentDest = newArray + destIdx[i];
currentSrc = Array + srcIdx[i];
size_t bytes = copyElements[i] * sizeof(T);
::memcpy(currentDest, currentSrc, bytes);
}
// We are done copying - delete the current Array
_deallocate();
// Allocation was successful. Save it.
this->Size = newSize;
this->Array = newArray;
// This object has now allocated its memory and owns it.
this->_ownsData = true;
this->MaxId = newSize - 1;
return err;
}
