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);
 }
    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);
    }
 protected function prepareDatasetRequestMetaData(AbstractDatasetQueryRequest $request)
 {
     $this->getDatasetMetaData($request->getDatasetName());
 }
 protected function prepareDatasetQueryStatements(DataControllerCallContext $callcontext, AbstractDatasetQueryRequest $request)
 {
     $metamodel = data_controller_get_metamodel();
     $datasetName = $request->getDatasetName();
     $dataset = $metamodel->getDataset($datasetName);
     $requestedColumns = $request instanceof DatasetCountRequest ? array() : $request->columns;
     // preparing list of columns which are accessed by this request
     $usedColumnNames = $requestedColumns;
     if (isset($usedColumnNames) && isset($request->queries)) {
         foreach ($request->queries as $query) {
             foreach ($query as $columnName => $values) {
                 ArrayHelper::addUniqueValue($usedColumnNames, $columnName);
             }
         }
     }
     // preparing dataset source
     $baseStatement = $this->prepareDatasetSourceStatement($callcontext, $dataset, $usedColumnNames);
     if (isset($request->queries)) {
         $statements = NULL;
         foreach ($request->queries as $query) {
             $statement = clone $baseStatement;
             // adding additional conditions
             foreach ($query as $columnName => $values) {
                 // detecting data type for the column
                 $databaseColumnName = ReferencePathHelper::assembleDatabaseColumnName($this->getMaximumEntityNameLength(), $columnName);
                 $table = $statement->getColumnTable($databaseColumnName, TRUE);
                 $column = $table->findColumnByAlias($databaseColumnName);
                 foreach ($values as $value) {
                     $conditionValue = new ExactConditionSectionValue($this->formatOperatorValue($callcontext, $request, $dataset->name, $columnName, $value));
                     $statement->conditions[] = $column instanceof CompositeColumnSection ? new CompositeWhereConditionSection($table->alias, $column, $conditionValue) : new WhereConditionSection($table->alias, isset($column) ? $column->name : $databaseColumnName, $conditionValue);
                 }
             }
             $statements[] = $statement;
         }
         return $statements;
     } else {
         return array($baseStatement);
     }
 }