protected function selectBoundary4DatasetRequest(DataControllerCallContext $callcontext, AbstractDatasetQueryRequest $request, $datasetName, $columnName)
{
// looking for an index where this instance is used. Rest of the queries will be ignored.
// Data for ignored queries will be calculated during subsequent requests to different instances of this class
$selectedIndex = NULL;
if (isset($request->queries)) {
foreach ($request->queries as $index => $query) {
foreach ($query as $values) {
foreach ($values as $value) {
if ($this->operatorHandler === $value) {
$selectedIndex = $index;
break 3;
}
}
}
}
}
$expressionRequest = new DatasetQueryRequest($request->getDatasetName());
// returning only observing column
$expressionRequest->addColumn($columnName);
// excluding records with NULL value for the observing column
$expressionRequest->addQueryValue(0, $columnName, data_controller_get_operator_factory_instance()->initiateHandler(NotEqualOperatorHandler::$OPERATOR__NAME, NULL));
// adding support for queries except this operator handler
if (isset($selectedIndex)) {
foreach ($request->queries[$selectedIndex] as $name => $values) {
foreach ($values as $value) {
if ($value->isSubsetBased()) {
// skipping other instances which are based on subset of data if their weight is greater than of this operator
if (isset($value->weight) && $value->weight > $this->operatorHandler->weight) {
continue;
}
}
if ($this->operatorHandler === $value) {
continue;
}
$expressionRequest->addQueryValue(0, $name, $value);
}
}
} else {
// we have this situation because we call this operator for a request where thus operator is not used
}
// sorting data
$expressionRequest->addOrderByColumn(PropertyBasedComparator_DefaultSortingConfiguration::assembleDirectionalPropertyName($columnName, $this->isSortAscending()));
// limiting response to one record
$expressionRequest->setPagination(1, 0);
return $this->processDatasetExpressionRequest($callcontext, $expressionRequest, $columnName);
}
public function getDatasetMetaData(DataControllerCallContext $callcontext, DatasetMetaData $dataset) {
// TODO Change implementation of the method and work with provided $dataset
list($metadataDatasetName, $schemaDocumentId) = $this->getMetaDataStorageProperties($callcontext, $dataset->name);
// loading schema for the dataset
$schemaLoadRequest = new DatasetQueryRequest($metadataDatasetName);
$schemaLoadRequest->addQueryValue(0, '_id', $schemaDocumentId);
$schema = $this->queryDataset($callcontext, $schemaLoadRequest, NULL);
$metadata = new DatasetMetaData();
if (isset($schema)) {
foreach ($schema[0]->properties as $propertyName => $property) {
$column = $metadata->registerColumn($propertyName);
// TODO support other properties of ColumnType class
$column->type->applicationType = $property->type;
$column->key = $property->key;
}
}
}
protected function selectBoundary4DatasetRequest(DataControllerCallContext $callcontext, AbstractDatasetQueryRequest $request, $datasetName, $columnName) {
// looking for an index where this instance is used. Rest of the queries will be ignored.
// Data for ignored queries will be calculated during subsequent requests to different instances of this class
$selectedIndex = NULL;
if (isset($request->queries)) {
foreach ($request->queries as $index => $query) {
foreach ($query as $values) {
foreach ($values as $value) {
if ($this->operatorHandler === $value) {
$selectedIndex = $index;
break 3;
}
}
}
}
}
$expressionRequest = new DatasetQueryRequest($request->getDatasetName());
// needs to be called before any additional methods are called
$expressionRequest->addOptions($request->options);
// returning only observing column
$expressionRequest->addColumn($columnName);
// excluding records with NULL value for the observing column
$expressionRequest->addQueryValue(
0,
$columnName, OperatorFactory::getInstance()->initiateHandler(NotEqualOperatorHandler::OPERATOR__NAME, NULL));
// adding support for queries except this operator handler
if (isset($selectedIndex)) {
foreach ($request->queries[$selectedIndex] as $name => $values) {
foreach ($values as $value) {
if ($this->shouldValueBeSkipped($value)) {
continue;
}
if ($this->operatorHandler === $value) {
continue;
}
$expressionRequest->addQueryValue(0, $name, $value);
}
}
}
else {
// we have this situation because we call this operator for a request where this operator is not used
}
// sorting data
$expressionRequest->addOrderByColumn(
ColumnBasedComparator_AbstractSortingConfiguration::assembleDirectionalColumnName($columnName, $this->isSortAscending()));
// limiting response to one record
$expressionRequest->setPagination(1, 0);
return $this->processDatasetExpressionRequest($callcontext, $expressionRequest, $columnName);
}
public function insertOrUpdateOrDeleteDatasetRecords(DataControllerCallContext $callcontext, AbstractDatasetManipulationRequest $request) {
$environment_metamodel = data_controller_get_environment_metamodel();
$metamodel = data_controller_get_metamodel();
$datasourceQueryHandler = DataSourceQueryFactory::getInstance()->getHandler($this->getDataSourceType());
$dataset = $metamodel->getDataset($request->datasetName);
$datasource = $environment_metamodel->getDataSource($dataset->datasourceName);
$recordMetaData = isset($request->recordsHolder->recordMetaData) ? $request->recordsHolder->recordMetaData : $dataset;
$isRecordIndexed = $request->recordsHolder instanceof IndexedRecordsHolder;
$keyColumnNames = $recordMetaData->getKeyColumnNames();
$nonkeyColumnNames = $recordMetaData->findNonKeyColumnNames();
// preparing a request to find existing records
$queryRequest = new DatasetQueryRequest($request->datasetName);
// loading only key columns from database
$queryRequest->addColumns($keyColumnNames);
// a request can be more efficient for single column key
if (count($keyColumnNames) == 1) {
list($keyColumnIndex, $keyColumnName) = each($keyColumnNames);
$keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName;
$keyValues = NULL;
foreach ($request->recordsHolder->records as $record) {
ArrayHelper::addUniqueValue($keyValues, $record->getColumnValue($keyColumnIdentifier, TRUE));
}
$queryRequest->addQueryValue(
0,
$keyColumnName, OperatorFactory::getInstance()->initiateHandler(EqualOperatorHandler::OPERATOR__NAME, array($keyValues)));
}
else {
for ($i = 0, $count = count($request->recordsHolder->records); $i < $count; $i++) {
$record = $request->recordsHolder->records[$i];
foreach ($keyColumnNames as $keyColumnIndex => $keyColumnName) {
$keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName;
$keyColumnValue = $record->getColumnValue($keyColumnIdentifier, TRUE);
$queryRequest->addQueryValue(
$i,
$keyColumnName, OperatorFactory::getInstance()->initiateHandler(EqualOperatorHandler::OPERATOR__NAME, $keyColumnValue));
}
}
}
// loading existing records ... if any
$existingRecordFormatter = new QueryKeyResultFormatter($keyColumnNames);
$existingRecords = $existingRecordFormatter->formatRecords($datasourceQueryHandler->queryDataset($callcontext, $queryRequest));
// sorting out records for insert, update and delete operations
$keyedRecords = $insertedRecordKeys = $updatedRecordKeys = $deletedRecordKeys = NULL;
foreach ($request->recordsHolder->records as $record) {
$keyParts = NULL;
foreach ($keyColumnNames as $keyColumnIndex => $keyColumnName) {
$keyColumnIdentifier = $isRecordIndexed ? $keyColumnIndex : $keyColumnName;
$keyParts[] = $record->getColumnValue($keyColumnIdentifier, TRUE);
}
$key = ArrayHelper::prepareCompositeKey($keyParts);
$keyedRecords[$key] = $record;
// checking if the record has to be deleted
$isDeletable = TRUE;
if (isset($nonkeyColumnNames)) {
foreach ($nonkeyColumnNames as $columnIndex => $columnName) {
$columnIdentifier = $isRecordIndexed ? $columnIndex : $columnName;
if ($record->getColumnValue($columnIdentifier) != NULL) {
$isDeletable = FALSE;
break;
}
}
}
else {
// the dataset has NO non-key columns. We should not delete these records
$isDeletable = FALSE;
}
if ($isDeletable) {
unset($insertedRecordKeys[$key]);
unset($updatedRecordKeys[$key]);
// the record physically present in database and needs to be deleted
if (isset($existingRecords[$key])) {
unset($existingRecords[$key]);
$deletedRecordKeys[$key] = TRUE;
}
}
elseif (isset($insertedRecordKeys[$key])) {
// the key has been already used to insert a record within this batch. This record needs to be part of update operation
$updatedRecordKeys[$key] = TRUE;
}
elseif (isset($existingRecords[$key])) {
$updatedRecordKeys[$key] = TRUE;
}
else {
$insertedRecordKeys[$key] = TRUE;
}
}
$sqls = NULL;
// deleting existing records
$deletedRecordCount = 0;
if (isset($deletedRecordKeys)) {
$deleteRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $deletedRecordKeys);
// preparing request
$deleteRequest = new DatasetDeleteRequest($request->datasetName, $deleteRecordHolder);
// preparing statements to delete records from the database
ArrayHelper::appendValue($sqls, $this->prepareDeleteDatasetRecordStatements($callcontext, $deleteRequest));
$deletedRecordCount = count($deleteRecordHolder->records);
}
// inserting new records
$insertedRecordCount = 0;
if (isset($insertedRecordKeys)) {
$insertRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $insertedRecordKeys);
// preparing request
$insertRequest = new DatasetInsertRequest($request->datasetName, $insertRecordHolder);
// preparing statements to insert records into the database
ArrayHelper::appendValue($sqls, $this->prepareInsertDatasetRecordStatements($callcontext, $insertRequest));
$insertedRecordCount = count($insertRecordHolder->records);
}
// updating existing records
$updatedRecordCount = 0;
if (isset($updatedRecordKeys)) {
$updateRecordHolder = $this->prepareRecordHolder($request, $keyedRecords, $updatedRecordKeys);
// preparing request
$updateRequest = new DatasetUpdateRequest($request->datasetName, $updateRecordHolder);
// preparing statements to update records in the database
ArrayHelper::appendValue($sqls, $this->prepareUpdateDatasetRecordStatements($callcontext, $updateRequest));
$updatedRecordCount = count($updateRecordHolder->records);
}
$affectedRecordCount = isset($sqls) ? $this->executeManipulationStatementBatch($datasource, $sqls) : 0;
if (($insertedRecordCount + $updatedRecordCount + $deletedRecordCount) < $affectedRecordCount) {
throw new IllegalStateException(t('Number of affected records is greater than expected number of inserted, updated and deleted records'));
}
return array($insertedRecordCount, $updatedRecordCount, $deletedRecordCount);
}
