public function executeFunction(FunctionJob $function, ExecutionContext $context)
{
/* @var $schemaManager SchemaManager */
$schemaManager = $context->getSchemaManager();
$databaseId = $schemaManager->getCurrentlyUsedDatabaseId();
return $databaseId;
}
public function resolveSourceRow(array $row, ExecutionContext $context)
{
/* @var $statement StatementJob */
$statement = $context->getStatement();
$resultRow = array();
foreach ($statement->getResultSpecifier() as $resultColumn) {
/* @var $resultColumn Column */
$this->resolveResultColumn($resultColumn, $resultRow, $context);
}
return $resultRow;
}
public function executeFunction(FunctionJob $function, ExecutionContext $context)
{
/* @var $argumentValue Value */
$argumentValue = current($function->getArguments());
$beforeSourceRow = $context->getCurrentSourceRow();
$sum = 0;
foreach ($context->getCurrentSourceSet() as $row) {
$context->setCurrentSourceRow($row);
$value = $this->valueResolver->resolveValue($argumentValue, $context);
if (is_numeric($value)) {
$sum += $value;
}
}
$context->setCurrentSourceRow($beforeSourceRow);
return $sum;
}
public function executeJob(StatementJob $statement, array $parameters = array())
{
/* @var $statement UpdateStatement */
$result = new TemporaryResult();
// TODO: multiple tables or not?
$executionContext = new ExecutionContext($this->schemaManager, $statement, $parameters, $this->valueResolver);
/* @var $tableSpecifier TableSpecifier */
$tableSpecifier = $statement->getTables()[0];
/* @var $tableResource Table */
$tableResource = $this->tableManager->getTable($tableSpecifier->getTable(), $tableSpecifier->getDatabase());
/* @var $tableSchema TableSchema */
$tableSchema = $tableResource->getTableSchema();
$indicies = array();
foreach ($tableSchema->getIndexIterator() as $indexId => $indexPage) {
/* @var $indexPage Index */
/* @var $index Index */
$index = $tableResource->getIndex($indexPage->getName());
$indicies[] = $index;
}
/* @var $condition Value */
$condition = $statement->getCondition();
foreach ($tableResource as $rowId => $row) {
if ($tableResource instanceof UsesBinaryDataInterface && $tableResource->usesBinaryData()) {
$row = $tableResource->convertDataRowToStringRow($row);
}
$executionContext->setCurrentSourceRow($row);
$conditionResult = $this->valueResolver->resolveValue($condition, $executionContext);
if ($conditionResult) {
$newRow = $row;
foreach ($statement->getDataChanges() as $dataChange) {
/* @var $dataChange DataChange */
$columnName = (string) $dataChange->getColumn();
$newValue = $dataChange->getValue();
$newValue = $this->valueResolver->resolveValue($newValue, $executionContext);
$newRow[$columnName] = $newValue;
}
$row = $tableResource->convertStringRowToDataRow($row);
$newRow = $tableResource->convertStringRowToDataRow($newRow);
foreach ($indicies as $index) {
/* @var $index Index */
$index->updateRow($row, $newRow, $rowId);
}
$tableResource->setRowData($rowId, $newRow);
}
}
return $result;
}
public function executeFunction(FunctionJob $function, ExecutionContext $context)
{
/* @var $result SelectResult */
$result = $this->resultSet;
/* @var $argumentValue Value */
$argumentValue = current($function->getArguments());
$count = 0;
$beforeSourceRow = $context->getCurrentSourceRow();
foreach ($context->getCurrentSourceSet() as $row) {
$context->setCurrentSourceRow($row);
$value = $this->valueResolver->resolveValue($argumentValue);
if (!is_null($value)) {
$count++;
}
}
$context->setCurrentSourceRow($beforeSourceRow);
return $count;
}
private function doesCurrentRowPassesFilters()
{
$row = $this->current();
$result = false;
if (is_array($row)) {
if ($this->usesBinaryData()) {
$row = $this->convertDataRowToStringRow($row);
}
$this->executionContext->setCurrentSourceRow($row);
$result = $this->valueResolver->resolveValue($this->condition, $this->executionContext);
}
return (bool) $result;
}
public function executeJob(StatementJob $statement, array $parameters = array())
{
/* @var $statement SelectStatement */
$defaultSchema = $this->schemaManager->getSchema();
$executionContext = new ExecutionContext($this->schemaManager, $statement, $parameters);
### COLLECT SOURCE TABLES
if (!is_null($statement->getJoinDefinition())) {
foreach ($statement->getJoinDefinition()->getTables() as $joinTable) {
/* @var $joinTable TableJoin */
/* @var $dataSource ParenthesisPart */
$dataSource = $joinTable->getDataSource();
$tableResource = null;
$alias = $dataSource->getAlias();
$dataSource = $dataSource->getContain();
if ($dataSource instanceof TableInterface) {
$tableResource = $dataSource;
if (is_null($alias)) {
$alias = $tableResource->getName();
}
}
if ($dataSource instanceof SelectStatement) {
/* @var $subQueryResult TemporaryResult */
$tableResource = $this->executeJob($dataSource, $parameters);
}
if ($dataSource instanceof TableSpecifier) {
if (!is_null($dataSource->getDatabase())) {
if (!$this->schemaManager->schemaExists($dataSource->getDatabase())) {
throw new InvalidArgumentException("Database '{$dataSource->getDatabase()}' does not exist!");
}
$schema = $this->schemaManager->getSchema($dataSource->getDatabase());
} else {
$schema = $defaultSchema;
}
if (!$schema->tableExists($dataSource->getTable())) {
throw new InvalidArgumentException("Table '{$dataSource}' does not exist!");
}
if (is_null($alias)) {
$alias = $dataSource->getTable();
}
$tableResource = $this->tableManager->getTable($dataSource->getTable(), $dataSource->getDatabase());
}
$executionContext->setTable($tableResource, (string) $alias);
}
}
### INIT RESULTSET
$resultColumns = array();
foreach ($statement->getColumns() as $column) {
if ($column === '*') {
foreach ($executionContext->getTables() as $alias => $table) {
/* @var $table Table */
/* @var $tableSchema TableSchema */
$tableSchema = $table->getTableSchema();
foreach ($tableSchema->getColumnIterator() as $columnPage) {
/* @var $columnPage ColumnSchema */
$columnName = $columnPage->getName();
if (count($executionContext->getTables()) > 1) {
$columnName = "{$alias}.{$columnName}";
}
$resultColumns[] = $columnName;
}
}
} elseif ($column instanceof ValuePart) {
$resultColumns[] = $column->getAlias();
}
}
$result = new TemporaryResult($resultColumns);
$executionContext->setCurrentResultSet(new TemporaryResult($resultColumns));
$executionContext->setCurrentSourceSet(new TemporaryResult());
### PRE-FILTER SOURCE COLUMNS (currently not implemented)
if (!is_null($statement->getCondition())) {
/* @var $condition ValuePart */
$condition = $statement->getCondition();
$tableConditions = $this->findFixedConditions($condition);
foreach ($executionContext->getTables() as $alias => $table) {
/* @var $table TableInterface */
/* @var $tableSchema TableSchema */
$tableSchema = $table->getTableSchema();
$tableIterator = $table;
$indexes = $this->findIndexesForTableConditions($tableConditions, $table, $alias);
if (!empty($indexes)) {
# TODO: actually choose the best index instead of using the first usable index
# (We probably need table-statistics to do that.)
$index = $indexes[0];
/* @var $indexSchema IndexSchema */
$indexSchema = $index->getIndexSchema();
$indexecColumns = array();
foreach ($indexSchema->getColumns() as $columnId) {
$columnName = $tableSchema->getColumn($columnId)->getName();
$indexecColumns[$columnId] = $columnName;
}
$tableIterator = new FilteredResourceIterator($tableIterator, $condition, $this->valueResolver, $executionContext, $index, $indexecColumns);
}
if ($tableIterator !== $table) {
$executionContext->setTable($tableIterator, $alias);
}
}
}
/* @var $joinDefinition Join */
$joinDefinition = $statement->getJoinDefinition();
if (!is_null($joinDefinition)) {
### BUILD JOIN
if (count($joinDefinition->getTables()) > 1) {
$iterator = new JoinIterator($joinDefinition, $executionContext, $this, $this->valueResolver, $statement, null);
} else {
/* @var $tableJoin TableJoin */
$tableJoin = $joinDefinition->getTables()[0];
$tableSource = $tableJoin->getDataSource();
$alias = null;
while ($tableSource instanceof ParenthesisPart) {
if (is_null($alias)) {
$alias = $tableSource->getAlias();
}
$tableSource = $tableSource->getContain();
}
if ($tableSource instanceof TableSpecifier) {
if (is_null($alias)) {
$alias = $tableSource->getTable();
}
$iterator = $executionContext->getTable($alias);
} elseif ($tableSource instanceof SelectStatement) {
$iterator = $this->executeJob($tableSource);
} else {
throw new ErrorException("Unexpected object given as source for join!");
}
$iterator = new AliasedResourceIterator($iterator, $alias);
}
### FILTER RESULT
// WHERE condition
$condition = $statement->getCondition();
if (!is_null($condition)) {
if ($iterator instanceof IteratorAggreagte) {
$iterator = $iterator->getIterator();
}
$iterator = new FilteredResourceIterator($iterator, $condition, $this->valueResolver, $executionContext);
}
// ON/USING conditions from joins
foreach ($joinDefinition->getTables() as $joinTable) {
/* @var $joinTable TableJoin */
$joinCondition = $joinTable->getCondition();
if (!is_null($joinCondition)) {
if ($iterator instanceof IteratorAggreagte) {
$iterator = $iterator->getIterator();
}
$iterator = new FilteredResourceIterator($iterator, $joinCondition, $this->valueResolver, $executionContext);
}
}
### SET UP SORTING
$orderColumns = $statement->getOrderColumns();
if (count($orderColumns) > 0) {
$innerIterator = $iterator;
$iterator = new SortedResourceIterator($iterator, $this->valueResolver);
$iterator->setTemporaryBuildChildIteratorByValue($orderColumns, $innerIterator, $executionContext);
}
### WRITE RESULTSET
foreach ($iterator as $dataRow) {
if ($iterator instanceof UsesBinaryDataInterface && $iterator->usesBinaryData()) {
$dataRow = $iterator->convertDataRowToStringRow($dataRow);
}
$executionContext->getCurrentSourceSet()->addRow($dataRow);
$executionContext->setCurrentSourceRow($dataRow);
$resolvedRow = $this->valueResolver->resolveSourceRow($statement->getColumns(), $executionContext);
$executionContext->getCurrentResultSet()->addRow($resolvedRow);
}
} else {
// no joining (something like "SELECT 5+5 as foo")
$resolvedRow = $this->valueResolver->resolveSourceRow($statement->getColumns(), $executionContext);
$executionContext->getCurrentResultSet()->addRow($resolvedRow);
}
### UNLOCK TABLES
foreach ($executionContext->getTables() as $table) {
# TODO: unlock tables
}
### APPLY GROUPING
$groupings = $statement->getGroupings();
if (count($groupings) > 0) {
foreach ($groupings as $groupingDefinition) {
/* @var $groupingDefinition GroupingDefinition */
/* @var $groupingValue ValuePart */
$groupingValue = $groupingDefinition->getValue();
$beforeSourceRow = $executionContext->getCurrentSourceRow();
$groupedRows = array();
foreach ($executionContext->getCurrentSourceSet() as $row) {
$executionContext->setCurrentSourceRow($row);
$groupId = $this->valueResolver->resolveValue($groupingValue, $executionContext);
if (!isset($groupedRows[$groupId])) {
$groupedRows[$groupId] = array();
}
$groupedRows[$groupId][] = $row;
}
$groupedResultSet = new TemporaryResult($resultColumns);
foreach ($groupedRows as $groupId => $rows) {
if ($groupingDefinition->getDirection() === SqlToken::T_ASC()) {
$groupingMainRow = reset($rows);
} else {
$groupingMainRow = end($rows);
}
$currentGroupResultSet = new TemporaryResult();
foreach ($rows as $row) {
$currentGroupResultSet->addRow($row);
}
$executionContext->setCurrentSourceRow($groupingMainRow);
$executionContext->setCurrentSourceSet($currentGroupResultSet);
$resolvedRow = $this->valueResolver->resolveSourceRow($statement->getColumns(), $executionContext);
$groupedResultSet->addRow($resolvedRow);
}
$executionContext->setCurrentSourceRow($beforeSourceRow);
$executionContext->setCurrentResultSet($groupedResultSet);
}
}
### APPLY RESULT-FILTER (HAVING)
/* @var $resultFilter ConditionJob */
$resultFilter = $statement->getResultFilter();
if (!is_null($resultFilter)) {
$filteredResult = new TemporaryResult($resultColumns);
foreach ($executionContext->getCurrentResultSet() as $row) {
$executionContext->setCurrentSourceRow($row);
$passesFilter = (bool) $this->valueResolver->resolveValue($resultFilter, $executionContext);
if ($passesFilter) {
$filteredResult->addRow($row);
}
}
$executionContext->setCurrentResultSet($filteredResult);
}
### APPEND UNIONED SELECT
$unionSelect = $statement->getUnionSelect();
if (!is_null($unionSelect)) {
$unionResult = $this->executeJob($unionSelect, $parameters);
foreach ($unionResult as $unionRow) {
$executionContext->getCurrentResultSet()->addRow($unionRow);
}
}
return $executionContext->getCurrentResultSet();
}
public function executeJob(StatementJob $statement, array $parameters = array())
{
/* @var $statement DeleteStatement */
$result = new TemporaryResult();
$executionContext = new ExecutionContext($this->schemaManager, $statement, $parameters);
/* @var $conditionValue Value */
$conditionValue = $statement->getCondition();
$rowCount = 0;
$rowSkip = 0;
$limitOffset = $statement->getLimitOffset();
$limitCount = $statement->getLimitRowCount();
foreach ($statement->getDeleteTables() as $tableSpecifier) {
/* @var $tableSpecifier TableSpecifier */
/* @var $tableResource Table */
$tableResource = $this->tableManager->getTable($tableSpecifier->getTable(), $tableSpecifier->getDatabase());
$sortedIterator = new SortedResourceIterator($tableResource, $this->valueResolver);
/* @var $tableSchema TableSchema */
$tableSchema = $tableResource->getTableSchema();
if (!is_null($statement->getOrderColumn())) {
$orderColumns = $statement->getOrderColumn();
$sortedIterator->setTemporaryBuildChildIteratorByValue($orderColumns, $tableResource);
} else {
$primaryKeyColumns = $tableSchema->getPrimaryKeyColumns();
$primaryIndexId = $tableSchema->getIndexIdByColumns(array_keys($primaryKeyColumns));
if (!is_null($primaryIndexId)) {
/* @var $index Index */
$index = $tableResource->getIndex($primaryIndexId);
// TODO: try to extract begin/end values from conditions
$beginValue = null;
$endValue = null;
$iterator = $index->getIterator($beginValue, $endValue);
$sortedIterator->setChildIterator($iterator);
} else {
/* @var $sortIndex Quicksort */
$sortIndex = $sortedIterator->getSortIndexByColumns($primaryKeyColumns);
foreach ($tableResource as $rowId => $row) {
$sortIndex->addRow($rowId, $row);
}
$sortIndex->sort();
$sortedIterator->setChildIterator($sortIndex);
}
}
foreach ($sortedIterator as $rowId => $row) {
$executionContext->setCurrentSourceRow($row);
$isConditionMatch = true;
if (!is_null($conditionValue)) {
$isConditionMatch = $this->valueResolver->resolveValue($conditionValue, $executionContext);
}
if ($isConditionMatch) {
if (!is_null($limitOffset) && $rowSkip < $limitOffset) {
$rowSkip++;
continue;
}
if (!is_null($limitCount) && $rowCount > $limitCount) {
continue;
}
$rowCount++;
foreach ($tableResource->getTableSchema()->getIndexIterator() as $indexId => $indexPage) {
/* @var $indexPage Index */
/* @var $indexResource Index */
$indexResource = $tableResource->getIndex($indexId);
$originalRow = $tableResource->getRowData($rowId);
$rowIdStr = $this->decstr($rowId);
$indexResource->removeRow($originalRow, $rowIdStr);
}
$tableResource->removeRow($rowId);
}
}
}
return $result;
}
