public function queryDataset(DataControllerCallContext $callcontext, DatasetQueryRequest $request, ResultFormatter $resultFormatter) {
        $datasetName = $request->getDatasetName();

        $handler = $this->getDatasetHandler($callcontext, $datasetName);

        return $handler->queryDataset($callcontext, $request, $resultFormatter);
    }
    protected function prepareQueryDatasetRequest2CountRecords($callcontext, $countRequest) {
        $datasetName = $countRequest->getDatasetName();

        $dataRequest = new DatasetQueryRequest($datasetName);
        $dataRequest->addCompositeQueryValues($countRequest->queries);

        return $dataRequest;
    }
 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 prepareDatasetQueryRequest(DataQueryControllerDatasetRequest $request)
 {
     $datasourceRequest = new DatasetQueryRequest($request->datasetName);
     $datasourceRequest->addCompositeQueryValues($request->parameters);
     $datasourceRequest->addColumns($request->columns);
     $datasourceRequest->addOrderByColumns($request->orderBy);
     $datasourceRequest->setPagination($request->limit, $request->startWith);
     return $datasourceRequest;
 }
    public function prepareQueryRequest(DataQueryControllerDatasetRequest $request) {
        $datasourceRequest = new DatasetQueryRequest($request->datasetName);

        // needs to be called before any additional methods are called
        $datasourceRequest->addOptions($request->options);

        $datasourceRequest->addCompositeQueryValues($request->parameters);
        $datasourceRequest->addColumns($request->columns);
        $datasourceRequest->addOrderByColumns($request->orderBy);
        $datasourceRequest->setPagination($request->limit, $request->startWith);

        return $datasourceRequest;
    }
    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 queryDataset(DataControllerCallContext $callcontext, DatasetQueryRequest $request) {
        $datasetName = $request->getDatasetName();
        LogHelper::log_info(t('Querying script-based dataset: @datasetName', array('@datasetName' => $datasetName)));

        $metamodel = data_controller_get_metamodel();

        $dataset = $metamodel->getDataset($datasetName);

        $serializer = new DatasetQueryUIRequestSerializer();
        $parameters = $serializer->serialize($request);

        $records = $this->executeScriptFunction($dataset, 'queryDataset', $parameters);
        LogHelper::log_info(t('Received @count records(s)', array('@count' => count($records))));
        // converting type of returned values
        if (isset($records)) {
            $columnTypeHandlers = NULL;
            foreach ($records as &$record) {
                foreach ($record as $columnName => $columnValue) {
                    if (!isset($columnTypeHandlers[$columnName])) {
                        $type = $dataset->getColumn($columnName)->type->applicationType;
                        $columnTypeHandlers[$columnName] = DataTypeFactory::getInstance()->getHandler($type);
                    }
                    $record[$columnName] = $columnTypeHandlers[$columnName]->castValue($columnValue);
                }
            }
            unset($record);
        }
        LogHelper::log_debug($records);

        return $records;
    }
    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);
    }
 public function queryDataset(DataControllerCallContext $callcontext, DatasetQueryRequest $request, ResultFormatter $resultFormatter)
 {
     $datasetName = $request->getDatasetName();
     LogHelper::log_notice(t('Querying SQL-based dataset: @datasetName', array('@datasetName' => $datasetName)));
     $environment_metamodel = data_controller_get_environment_metamodel();
     $metamodel = data_controller_get_metamodel();
     $dataset = $metamodel->getDataset($datasetName);
     $datasource = $environment_metamodel->getDataSource($dataset->datasourceName);
     $statements = $this->prepareDatasetQueryStatements($callcontext, $request);
     $sql = $this->assembleDatasetQueryStatements($callcontext, $request, $statements);
     // applying ordering
     $sql = $this->applyOrderBy($sql, $request);
     // applying pagination
     $this->applyPagination($request, $sql);
     LogHelper::log_info(new StatementLogMessage('dataset.query', $sql));
     return $this->executeQuery($callcontext, $datasource, $sql, $resultFormatter);
 }
    protected function prepareDatasetRecords4Submission(DataControllerCallContext $callcontext, $request) {
        $preparedRecords = NULL;

        $datasetName = $request->getDatasetName();

        $isOperationInsert = $request->getOperationName() == DatasetInsertRequest::$OPERATION__INSERT;
        $isOperationDelete = $request->getOperationName() == DatasetDeleteRequest::$OPERATION__DELETE;

        $recordMetaData = $request->recordsHolder->recordMetaData;
        $keyColumn = $recordMetaData->findKeyColumn();
        $keyColumnName = isset($keyColumn) ? $keyColumn->name : NULL;

        $documentIds = NULL;
        if ($request->recordsHolder instanceof IndexedRecordsHolder) {
            $columnCount = $recordMetaData->getColumnCount();

            foreach ($request->recordsHolder->records as $record) {
                $preparedRecord = NULL;

                for ($i = 0; $i < $columnCount; $i++) {
                    $column = $recordMetaData->columns[$i];

                    $columnValue = $record[$i];
                    if (isset($columnValue)) {
                        $preparedRecord->{$column->name} = $columnValue;
                    }
                }

                // preparing document identifier
                if (!isset($preparedRecord->_id) && isset($keyColumnName)) {
                    $preparedRecord->_id = $preparedRecord->$keyColumnName;
                }

                // collecting document identifiers to load last revisions
                if (!$isOperationInsert) {
                    if (isset($preparedRecord->_id)) {
                        $documentIds[] = $preparedRecord->_id;
                    }
                    else {
                        LogHelper::log_error($preparedRecord);
                        throw new IllegalArgumentException(t('Could not find document identifier for the document'));
                    }
                }

                $preparedRecords[] = $preparedRecord;
            }

        }
        else {
            foreach ($request->recordsHolder->records as $record) {
                // preparing document identifier
                if (!isset($record->_id) && isset($keyColumnName)) {
                    $record->_id = $record->$keyColumnName;
                }

                // collecting document identifiers to load last revisions
                if (!$isOperationInsert) {
                    if (isset($record->_id)) {
                        $documentIds[] = $record->_id;
                    }
                    else {
                        LogHelper::log_error($record);
                        throw new IllegalArgumentException(t('Could not find document identifier for the document'));
                    }
                }

                $preparedRecords[] = $record;
            }
        }

        if (!$isOperationInsert) {
            // loading previous revisions
            $revisions = NULL;
            if (isset($documentIds)) {
                $revisionRequest = new DatasetQueryRequest($datasetName);
                $revisionRequest->addQueryValues(0, '_id', $documentIds);

                $revisionResponse = $this->queryDataset($callcontext, $revisionRequest, NULL);

                if (isset($revisionResponse)) {
                    foreach ($revisionResponse as $revision) {
                        $revisions[$revision->_id] = $revision->_rev;
                    }
                }
            }

            foreach ($preparedRecords as $record) {
                // setting revision
                if ((isset($revisions) && isset($revisions[$record->_id]))) {
                    $record->_rev = $revisions[$record->_id];
                }
                else {
                    throw new IllegalArgumentException(t(
                    	'Could not find last revision for the document: @id',
                        array('@id' => $record->_id)));
                }

                if ($isOperationDelete) {
                    $record->_deleted = TRUE;
                }
            }
        }

        return $preparedRecords;
    }
    public function queryDataset(DataControllerCallContext $callcontext, DatasetQueryRequest $request) {
        $datasetName = $request->getDatasetName();
        LogHelper::log_info(t('Querying SQL-based dataset: @datasetName', array('@datasetName' => $datasetName)));

        $environment_metamodel = data_controller_get_environment_metamodel();
        $metamodel = data_controller_get_metamodel();

        $this->getExtension('adjustRequest')->adjustDatasetQueryRequest($this, $request);

        $dataset = $metamodel->getDataset($datasetName);
        $datasource = $environment_metamodel->getDataSource($dataset->datasourceName);

        $statements = $this->prepareDatasetQueryStatements($callcontext, $request);
        $sql = $this->assembleDatasetQueryStatements($callcontext, $request, $statements);

        // applying sorting
        if (isset($request->sortingConfigurations)) {
            $adjustedColumns = NULL;
            foreach ($request->sortingConfigurations as $sortingConfiguration) {
                // TODO try to use the same functionality for list and cube requests
                $adjustedColumn = DataSourceColumnNameHelper::generateFromParameterElements(
                    $this->getMaximumEntityNameLength(), $sortingConfiguration->getColumnName());
                // adjusting direction of the sorting
                if (!$sortingConfiguration->isSortAscending) {
                    $adjustedColumn = $adjustedColumn . ' DESC';
                }

                $adjustedColumns[] = $adjustedColumn;
            }

            if (count($adjustedColumns) > 0) {
                $sql .= "\n ORDER BY " . implode(', ', $adjustedColumns);
            }
        }

        // applying pagination
        $this->applyPagination($request, $sql);

        LogHelper::log_info(new StatementLogMessage('dataset.query', $sql));
        return $this->executeQuery($callcontext, $datasource, $sql);
    }