SemanticMediaWiki/includes/storage/SMW_SparqlStoreQueryEngine.php

Go to the documentation of this file.

<?php

abstract class SMWSparqlCondition {

        public $orderByVariable = '';

        public $orderVariables = array();

        public $weakConditions = array();

        public $namespaces = array();

        abstract public function getCondition();

        abstract public function isSafe();

        public function getWeakConditionString() {
                return implode( '', $this->weakConditions );
        }

}

class SMWSparqlFalseCondition extends SMWSparqlCondition {

        public function getCondition() {
                return "<http://www.example.org> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#nothing> .\n";
        }

        public function isSafe() {
                return true;
        }
}

class SMWSparqlTrueCondition extends SMWSparqlCondition {

        public function getCondition() {
                return '';
        }

        public function isSafe() {
                return false;
        }
}

class SMWSparqlWhereCondition extends SMWSparqlCondition {

        public $condition;

        public $isSafe;

        public function __construct( $condition, $isSafe, $namespaces ) {
                $this->condition  = $condition;
                $this->isSafe     = $isSafe;
                $this->namespaces = $namespaces;
        }

        public function getCondition() {
                return $this->condition;
        }

        public function isSafe() {
                return $this->isSafe;
        }
}

class SMWSparqlSingletonCondition extends SMWSparqlCondition {

        public $condition;

        public $matchElement;

        public $isSafe;

        public function __construct( SMWExpElement $matchElement, $condition = '', $isSafe = false, $namespaces = array() ) {
                $this->matchElement = $matchElement;
                $this->condition  = $condition;
                $this->isSafe     = $isSafe;
                $this->namespaces = $namespaces;
        }

        public function getCondition() {
                return $this->condition;
        }

        public function isSafe() {
                return $this->isSafe;
        }

}

class SMWSparqlFilterCondition extends SMWSparqlCondition {

        public $filter;

        public function __construct( $filter, $namespaces ) {
                $this->filter = $filter;
                $this->namespaces = $namespaces;
        }

        public function getCondition() {
                return "FILTER( {$this->filter} )\n";
        }

        public function isSafe() {
                return false;
        }

}


class SMWSparqlStoreQueryEngine {

        const RESULT_VARIABLE = 'result';

        protected $m_variableCounter = 0;

        protected $m_sortkeys;

        protected $m_store;

        public function __construct( SMWStore $store ) {
                $this->m_store = $store;
        }

        public function getCountQueryResult( SMWQuery $query ) {
                $this->m_sortkeys = array(); // ignore sorting, just count
                $sparqlCondition = $this->getSparqlCondition( $query->getDescription() );

                if ( $sparqlCondition instanceof SMWSparqlSingletonCondition ) {
                        if ( $sparqlCondition->condition === '' ) { // all URIs exist, no querying
                                return 1;
                        } else {
                                $condition = $this->getSparqlConditionString( $sparqlCondition );
                                $namespaces = $sparqlCondition->namespaces;
                                $askQueryResult = smwfGetSparqlDatabase()->ask( $condition, $namespaces );
                                return $askQueryResult->isBooleanTrue() ? 1 : 0;
                        }
                } elseif ( $sparqlCondition instanceof SMWSparqlFalseCondition ) {
                        return 0;
                } else {
                        //debug_zval_dump( $condition );
                        $condition = $this->getSparqlConditionString( $sparqlCondition );
                        $namespaces = $sparqlCondition->namespaces;
                        $options = $this->getSparqlOptions( $query, $sparqlCondition );
                        $options['DISTINCT'] = true;
                        $sparqlResultWrapper = smwfGetSparqlDatabase()->selectCount( '?' . self::RESULT_VARIABLE,
                                                              $condition, $options, $namespaces );

                        if ( $sparqlResultWrapper->getErrorCode() == SMWSparqlResultWrapper::ERROR_NOERROR ) {
                                return (int)$sparqlResultWrapper->getNumericValue();
                        } else {
//                              $result->addErrors( array( wfMsgForContent( 'smw_db_sparqlqueryproblem' ) ) );
                        }
                }
        }

        public function getInstanceQueryResult( SMWQuery $query ) {
                $this->m_sortkeys = $query->sortkeys;
                $sparqlCondition = $this->getSparqlCondition( $query->getDescription() );
                //debug_zval_dump($sparqlCondition);

                if ( $sparqlCondition instanceof SMWSparqlSingletonCondition ) {
                        $matchElement = $sparqlCondition->matchElement;
                        if ( $sparqlCondition->condition === '' ) { // all URIs exist, no querying
                                $results = array( array ( $matchElement ) );
                        } else {
                                $condition = $this->getSparqlConditionString( $sparqlCondition );
                                $namespaces = $sparqlCondition->namespaces;
                                $askQueryResult = smwfGetSparqlDatabase()->ask( $condition, $namespaces );
                                $results = $askQueryResult->isBooleanTrue() ? array( array ( $matchElement ) ) : array();
                        }
                        $sparqlResultWrapper = new SMWSparqlResultWrapper( array( self::RESULT_VARIABLE => 0 ), $results );
                } elseif ( $sparqlCondition instanceof SMWSparqlFalseCondition ) {
                        $sparqlResultWrapper = new SMWSparqlResultWrapper( array( self::RESULT_VARIABLE => 0 ), array() );
                } else {
                        //debug_zval_dump( $condition );
                        $condition = $this->getSparqlConditionString( $sparqlCondition );
                        $namespaces = $sparqlCondition->namespaces;
                        $options = $this->getSparqlOptions( $query, $sparqlCondition );
                        $options['DISTINCT'] = true;
                        $sparqlResultWrapper = smwfGetSparqlDatabase()->select( '?' . self::RESULT_VARIABLE,
                                                 $condition, $options, $namespaces );
                }

                //debug_zval_dump( $sparqlResultWrapper );
                return $this->getQueryResultFromSparqlResult( $sparqlResultWrapper, $query );
        }

        public function getDebugQueryResult( SMWQuery $query ) {
                $this->m_sortkeys = $query->sortkeys;
                $sparqlCondition = $this->getSparqlCondition( $query->getDescription() );

                $entries = array();

                if ( $sparqlCondition instanceof SMWSparqlSingletonCondition ) {
                        if ( $sparqlCondition->condition === '' ) { // all URIs exist, no querying
                                $sparql = 'None (no conditions).';
                        } else {
                                $condition = $this->getSparqlConditionString( $sparqlCondition );
                                $namespaces = $sparqlCondition->namespaces;
                                $sparql = smwfGetSparqlDatabase()->getSparqlForAsk( $condition, $namespaces );
                        }
                } elseif ( $sparqlCondition instanceof SMWSparqlFalseCondition ) {
                        $sparql = 'None (conditions can not be satisfied by anything).';
                } else {
                        $condition = $this->getSparqlConditionString( $sparqlCondition );
                        $namespaces = $sparqlCondition->namespaces;
                        $options = $this->getSparqlOptions( $query, $sparqlCondition );
                        $options['DISTINCT'] = true;
                        $sparql = smwfGetSparqlDatabase()->getSparqlForSelect( '?' . self::RESULT_VARIABLE,
                                                 $condition, $options, $namespaces );
                }
                $sparql = str_replace( array( '[',':',' ' ), array( '&#x005B;', '&#x003A;', '&#x0020;' ), $sparql );
                $entries['SPARQL Query'] = "<pre>$sparql</pre>";

                return SMWStore::formatDebugOutput( 'SMWSparqlStore', $entries, $query );
        }

        protected function getSparqlConditionString( SMWSparqlCondition &$sparqlCondition ) {
                $condition = $sparqlCondition->getWeakConditionString();
                if ( ( $condition === '' ) && !$sparqlCondition->isSafe() ) {
                        $swivtPageResource = SMWExporter::getSpecialNsResource( 'swivt', 'page' );
                        $condition = '?' . self::RESULT_VARIABLE . ' ' . $swivtPageResource->getQName() . " ?url .\n";
                }
                $condition .= $sparqlCondition->getCondition();

                if ( $sparqlCondition instanceof SMWSparqlSingletonCondition ) { // prepare for ASK, maybe rather use BIND?
                        $matchElement = $sparqlCondition->matchElement;
                        $matchElementName = SMWTurtleSerializer::getTurtleNameForExpElement( $matchElement );
                        if ( $matchElement instanceof SMWExpNsResource ) {
                                $sparqlCondition->namespaces[$matchElement->getNamespaceId()] = $matchElement->getNamespace();
                        }
                        $condition = str_replace( '?' . self::RESULT_VARIABLE . ' ', "$matchElementName ", $condition );
                }

                return $condition;
        }

        protected function getQueryResultFromSparqlResult( SMWSparqlResultWrapper $sparqlResultWrapper, SMWQuery $query ) {
                $resultDataItems = array();
                
                foreach ( $sparqlResultWrapper as $resultRow ) {
                        if ( count( $resultRow ) > 0 ) {
                                $dataItem = SMWExporter::findDataItemForExpElement( $resultRow[0] );
                                
                                if ( !is_null( $dataItem ) ) {
                                        $resultDataItems[] = $dataItem;
                                }
                        }
                }

                if ( $sparqlResultWrapper->numRows() > $query->getLimit() ) {
                        array_pop( $resultDataItems );
                        $hasFurtherResults = true;
                } else {
                        $hasFurtherResults = false;
                }

                $result = new SMWQueryResult(  $query->getDescription()->getPrintrequests(), $query, $resultDataItems, $this->m_store, $hasFurtherResults );

                switch ( $sparqlResultWrapper->getErrorCode() ) {
                        case SMWSparqlResultWrapper::ERROR_NOERROR: break;
                        case SMWSparqlResultWrapper::ERROR_INCOMPLETE:
                                $result->addErrors( array( wfMsgForContent( 'smw_db_sparqlqueryincomplete' ) ) );
                        break;
                        default:
                                $result->addErrors( array( wfMsgForContent( 'smw_db_sparqlqueryproblem' ) ) );
                        break;
                }

                return $result;
        }

        protected function getSparqlCondition( SMWDescription $description ) {
                $this->m_variableCounter = 0;
                $sparqlCondition = $this->buildSparqlCondition( $description, self::RESULT_VARIABLE, null );
                $this->addMissingOrderByConditions( $sparqlCondition );
                return $sparqlCondition;
        }

        protected function buildSparqlCondition( SMWDescription $description, $joinVariable, $orderByProperty ) {
                if ( $description instanceof SMWSomeProperty ) {
                        return $this->buildPropertyCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWNamespaceDescription ) {
                        return $this->buildNamespaceCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWConjunction ) {
                        return $this->buildConjunctionCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWDisjunction ) {
                        return $this->buildDisjunctionCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWClassDescription ) {
                        return $this->buildClassCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWValueDescription ) {
                        return $this->buildValueCondition( $description, $joinVariable, $orderByProperty );
                } elseif ( $description instanceof SMWConceptDescription ) {
                        return new SMWSparqlTrueCondition(); 
                } else { // (e.g. SMWThingDescription)
                        return $this->buildTrueCondition( $joinVariable, $orderByProperty );
                }
        }

        protected function buildConjunctionCondition( SMWConjunction $description, $joinVariable, $orderByProperty ) {
                $subDescriptions = $description->getDescriptions();
                if ( count( $subDescriptions ) == 0 ) { // empty conjunction: true
                        return $this->buildTrueCondition( $joinVariable, $orderByProperty );
                } elseif ( count( $subDescriptions ) == 1 ) { // conjunction with one element
                        return $this->buildSparqlCondition( reset( $subDescriptions ), $joinVariable, $orderByProperty );
                }

                $condition = '';
                $filter = '';
                $namespaces = $weakConditions = $orderVariables = array();
                $singletonMatchElement = null;
                $singletonMatchElementName = '';
                $hasSafeSubconditions = false;
                foreach ( $subDescriptions as $subDescription ) {
                        $subCondition = $this->buildSparqlCondition( $subDescription, $joinVariable, null );
                        if ( $subCondition instanceof SMWSparqlFalseCondition ) {
                                return new SMWSparqlFalseCondition();
                        } elseif ( $subCondition instanceof SMWSparqlTrueCondition ) {
                                // ignore true conditions in a conjunction
                        } elseif ( $subCondition instanceof SMWSparqlWhereCondition ) {
                                $condition .= $subCondition->condition;
                        } elseif ( $subCondition instanceof SMWSparqlFilterCondition ) {
                                $filter .= ( $filter ? ' && ' : '' ) . $subCondition->filter;
                        } elseif ( $subCondition instanceof SMWSparqlSingletonCondition ) {
                                $matchElement = $subCondition->matchElement;
                                $matchElementName = SMWTurtleSerializer::getTurtleNameForExpElement( $matchElement );
                                if ( $matchElement instanceof SMWExpNsResource ) {
                                        $namespaces[$matchElement->getNamespaceId()] = $matchElement->getNamespace();
                                }

                                if ( ( !is_null( $singletonMatchElement ) ) &&
                                     ( $singletonMatchElementName !== $matchElementName ) ) {
                                        return new SMWSparqlFalseCondition();
                                }

                                $condition .= $subCondition->condition;
                                $singletonMatchElement = $subCondition->matchElement;
                                $singletonMatchElementName = $matchElementName;
                        }
                        $hasSafeSubconditions = $hasSafeSubconditions || $subCondition->isSafe();
                        $namespaces = array_merge( $namespaces, $subCondition->namespaces );
                        $weakConditions = array_merge( $weakConditions, $subCondition->weakConditions );
                        $orderVariables = array_merge( $orderVariables, $subCondition->orderVariables );
                }

                if ( !is_null( $singletonMatchElement ) ) {
                        if ( $filter !== '' ) {
                                $condition .= "FILTER( $filter )";
                        }
                        $result = new SMWSparqlSingletonCondition( $singletonMatchElement, $condition,
                                                                   $hasSafeSubconditions, $namespaces );
                } elseif ( $condition === '' ) {
                        $result = new SMWSparqlFilterCondition( $filter, $namespaces );
                } else {
                        if ( $filter !== '' ) {
                                $condition .= "FILTER( $filter )";
                        }
                        $result = new SMWSparqlWhereCondition( $condition, $hasSafeSubconditions, $namespaces );
                }

                $result->weakConditions = $weakConditions;
                $result->orderVariables = $orderVariables;

                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty );

                return $result;
        }

        protected function buildDisjunctionCondition( SMWDisjunction $description, $joinVariable, $orderByProperty ) {
                $subDescriptions = $description->getDescriptions();
                if ( count( $subDescriptions ) == 0 ) { // empty disjunction: false
                        return new SMWSparqlFalseCondition();
                } elseif ( count( $subDescriptions ) == 1 ) { // disjunction with one element
                        return $this->buildSparqlCondition( reset( $subDescriptions ), $joinVariable, $orderByProperty );
                } // else: proper disjunction; note that orderVariables found in subconditions cannot be used for the whole disjunction

                $unionCondition = '';
                $filter = '';
                $namespaces = $weakConditions = array();
                $hasSafeSubconditions = false;
                foreach ( $subDescriptions as $subDescription ) {
                        $subCondition = $this->buildSparqlCondition( $subDescription, $joinVariable, null );
                        if ( $subCondition instanceof SMWSparqlFalseCondition ) {
                                // empty parts in a disjunction can be ignored
                        } elseif ( $subCondition instanceof SMWSparqlTrueCondition ) {
                                return  $this->buildTrueCondition( $joinVariable, $orderByProperty );
                        } elseif ( $subCondition instanceof SMWSparqlWhereCondition ) {
                                $hasSafeSubconditions = $hasSafeSubconditions || $subCondition->isSafe();
                                $unionCondition .= ( $unionCondition ? ' UNION ' : '' ) .
                                                   "{\n" . $subCondition->condition . "}";
                        } elseif ( $subCondition instanceof SMWSparqlFilterCondition ) {
                                $filter .= ( $filter ? ' || ' : '' ) . $subCondition->filter;
                        } elseif ( $subCondition instanceof SMWSparqlSingletonCondition ) {
                                $hasSafeSubconditions = $hasSafeSubconditions || $subCondition->isSafe();
                                $matchElement = $subCondition->matchElement;
                                $matchElementName = SMWTurtleSerializer::getTurtleNameForExpElement( $matchElement );
                                if ( $matchElement instanceof SMWExpNsResource ) {
                                        $namespaces[$matchElement->getNamespaceId()] = $matchElement->getNamespace();
                                }
                                if ( $subCondition->condition === '' ) {
                                        $filter .= ( $filter ? ' || ' : '' ) . "?$joinVariable = $matchElementName";
                                } else {
                                        $unionCondition .= ( $unionCondition ? ' UNION ' : '' ) .
                                                   "{\n" . $subCondition->condition . " FILTER( ?$joinVariable = $matchElementName ) }";
                                }
                        }
                        $namespaces = array_merge( $namespaces, $subCondition->namespaces );
                        $weakConditions = array_merge( $weakConditions, $subCondition->weakConditions );
                }

                if ( ( $unionCondition === '' ) && ( $filter === '' ) ) {
                        return new SMWSparqlFalseCondition();
                } elseif ( $unionCondition === '' ) {
                        $result = new SMWSparqlFilterCondition( $filter, $namespaces );
                } elseif ( $filter === '' ) {
                        $result = new SMWSparqlWhereCondition( $unionCondition, $hasSafeSubconditions, $namespaces );
                } else {
                        $subJoinVariable = $this->getNextVariable();
                        $unionCondition = str_replace( "?$joinVariable ", "?$subJoinVariable ", $unionCondition );
                        $filter .= " || ?$joinVariable = ?$subJoinVariable";
                        $result = new SMWSparqlWhereCondition( "OPTIONAL { $unionCondition }\n FILTER( $filter )\n", false, $namespaces );
                }

                $result->weakConditions = $weakConditions;

                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty );

                return $result;

        }

        protected function buildPropertyCondition( SMWSomeProperty $description, $joinVariable, $orderByProperty ) {
                $diProperty = $description->getProperty();

                //*** Find out if we should order by the values of this property ***//
                if ( array_key_exists( $diProperty->getKey(), $this->m_sortkeys ) ) {
                        $innerOrderByProperty = $diProperty;
                } else {
                        $innerOrderByProperty = null;
                }

                //*** Prepare inner condition ***//
                $innerJoinVariable = $this->getNextVariable();
                $innerCondition = $this->buildSparqlCondition( $description->getDescription(), $innerJoinVariable, $innerOrderByProperty );
                $namespaces = $innerCondition->namespaces;

                if ( $innerCondition instanceof SMWSparqlFalseCondition ) {
                        return new SMWSparqlFalseCondition();
                } elseif ( $innerCondition instanceof SMWSparqlSingletonCondition ) {
                        $matchElement = $innerCondition->matchElement;
                        $objectName = SMWTurtleSerializer::getTurtleNameForExpElement( $matchElement );
                        if ( $matchElement instanceof SMWExpNsResource ) {
                                $namespaces[$matchElement->getNamespaceId()] = $matchElement->getNamespace();
                        }
                } else {
                        $objectName = '?' . $innerJoinVariable;
                }

                //*** Exchange arguments when property is inverse ***//
                if ( $diProperty->isInverse() ) { // don't check if this really makes sense
                        $subjectName = $objectName;
                        $objectName = '?' . $joinVariable;
                        $diNonInverseProperty = new SMWDIProperty( $diProperty->getKey(), false );
                } else {
                        $subjectName = '?' . $joinVariable;
                        $diNonInverseProperty = $diProperty;
                }

                //*** Build the condition ***//
                $typeId = $diProperty->findPropertyTypeID();
                $diType = SMWDataValueFactory::getDataItemId( $typeId );
                // for types that use helper properties in encoding values, refer to this helper property:
                if ( SMWExporter::hasHelperExpElement( $diType ) ) {
                        $propertyExpElement = SMWExporter::getResourceElementForProperty( $diNonInverseProperty, true );
                } else {
                        $propertyExpElement = SMWExporter::getResourceElementForProperty( $diNonInverseProperty );
                }
                $propertyName = SMWTurtleSerializer::getTurtleNameForExpElement( $propertyExpElement );
                if ( $propertyExpElement instanceof SMWExpNsResource ) {
                        $namespaces[$propertyExpElement->getNamespaceId()] = $propertyExpElement->getNamespace();
                }
                $condition = "$subjectName $propertyName $objectName .\n";
                $innerConditionString = $innerCondition->getCondition() . $innerCondition->getWeakConditionString();
                if ( $innerConditionString !== '' ) {
                        if ( $innerCondition instanceof SMWSparqlFilterCondition ) {
                                $condition .= $innerConditionString;
                        } else {
                                $condition .= "{ $innerConditionString}\n";
                        }
                }
                $result = new SMWSparqlWhereCondition( $condition, true, $namespaces );

                //*** Record inner ordering variable if found ***//
                $result->orderVariables = $innerCondition->orderVariables;
                if ( !is_null( $innerOrderByProperty ) && ( $innerCondition->orderByVariable !== '' ) ) {
                        $result->orderVariables[$diProperty->getKey()] = $innerCondition->orderByVariable;
                }

                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty, SMWDataItem::TYPE_WIKIPAGE );

                return $result;
        }

        protected function buildClassCondition( SMWClassDescription $description, $joinVariable, $orderByProperty ) {
                $condition = '';
                $namespaces = array();
                $instExpElement = SMWExporter::getSpecialPropertyResource( '_INST' );
                foreach( $description->getCategories() as $diWikiPage ) {
                        $categoryExpElement = SMWExporter::getResourceElementForWikiPage( $diWikiPage );
                        $categoryName = SMWTurtleSerializer::getTurtleNameForExpElement( $categoryExpElement );
                        $namespaces[$categoryExpElement->getNamespaceId()] = $categoryExpElement->getNamespace();
                        $newcondition = "{ ?$joinVariable " . $instExpElement->getQName() . " $categoryName . }\n";
                        if ( $condition === '' ) {
                                $condition = $newcondition;
                        } else {
                                $condition .= "UNION\n$newcondition";
                        }
                }

                if ( $condition === '' ) { // empty disjunction: always false, no results to order
                        return new SMWSparqlFalseCondition();
                }

                $result = new SMWSparqlWhereCondition( $condition, true, $namespaces );

                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty, SMWDataItem::TYPE_WIKIPAGE );

                return $result;
        }

        protected function buildNamespaceCondition( SMWNamespaceDescription $description, $joinVariable, $orderByProperty ) {
                $nspropExpElement = SMWExporter::getSpecialNsResource( 'swivt', 'wikiNamespace' );
                $nsExpElement = new SMWExpLiteral( $description->getNamespace(), 'http://www.w3.org/2001/XMLSchema#integer' );
                $nsName = SMWTurtleSerializer::getTurtleNameForExpElement( $nsExpElement );
                $condition = "{ ?$joinVariable " . $nspropExpElement->getQName() . " $nsName . }\n";

                $result = new SMWSparqlWhereCondition( $condition, true, array() );

                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty, SMWDataItem::TYPE_WIKIPAGE );

                return $result;
        }

        protected function buildValueCondition( SMWValueDescription $description, $joinVariable, $orderByProperty ) {
                $dataItem = $description->getDataItem();

                switch ( $description->getComparator() ) {
                        case SMW_CMP_EQ:   $comparator = '='; break;
                        case SMW_CMP_LESS: $comparator = '<'; break;
                        case SMW_CMP_GRTR: $comparator = '>'; break;
                        case SMW_CMP_LEQ:  $comparator = '<='; break;
                        case SMW_CMP_GEQ:  $comparator = '>='; break;
                        case SMW_CMP_NEQ:  $comparator = '!='; break;
                        case SMW_CMP_LIKE: $comparator = 'regex'; break;
                        case SMW_CMP_NLKE: $comparator = '!regex'; break;
                        default:           $comparator = ''; // unkown, unsupported
                }

                if ( $comparator === '' ) {
                        $result = $this->buildTrueCondition( $joinVariable, $orderByProperty );
                } elseif ( $comparator == '=' ) {
                        $expElement = SMWExporter::getDataItemHelperExpElement( $dataItem );
                        if ( is_null( $expElement ) ) {
                                $expElement = SMWExporter::getDataItemExpElement( $dataItem );
                        }
                        $result = new SMWSparqlSingletonCondition( $expElement );
                        $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty, $dataItem->getDIType() );
                } elseif ( $comparator == 'regex' || $comparator == '!regex' ) {
                        if ( $dataItem instanceof SMWDIBlob ) {
                                $pattern = '^' . str_replace( array( '^', '.', '\\', '+', '{', '}', '(', ')', '|', '^', '$', '[', ']', '*', '?' ),
                                                              array( '\^', '\.', '\\\\', '\+', '\{', '\}', '\(', '\)', '\|', '\^', '\$', '\[', '\]', '.*', '.' ),
                                                              $dataItem->getString() ) . '$';
                                $result = new SMWSparqlFilterCondition( "$comparator( ?$joinVariable, \"$pattern\", \"s\")", array() );
                                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty, $dataItem->getDIType() );
                        } else {
                                $result = $this->buildTrueCondition( $joinVariable, $orderByProperty );
                        }
                } else {
                        $result = new SMWSparqlFilterCondition( '', array() );
                        $this->addOrderByData( $result, $joinVariable, $dataItem->getDIType() );
                        $orderByVariable = $result->orderByVariable;

                        if ( $dataItem instanceof SMWDIWikiPage ) {
                                $expElement = SMWExporter::getDataItemExpElement( $dataItem->getSortKeyDataItem() );
                        } else {
                                $expElement = SMWExporter::getDataItemHelperExpElement( $dataItem );
                                if ( is_null( $expElement ) ) {
                                        $expElement = SMWExporter::getDataItemExpElement( $dataItem );
                                }
                        }

                        $valueName = SMWTurtleSerializer::getTurtleNameForExpElement( $expElement );
                        if ( $expElement instanceof SMWExpNsResource ) {
                                $result->namespaces[$expElement->getNamespaceId()] = $expElement->getNamespace();
                        }
                        $result->filter = "?$orderByVariable $comparator $valueName";
                }

                return $result;
        }

        protected function buildTrueCondition( $joinVariable, $orderByProperty ) {
                $result = new SMWSparqlTrueCondition();
                $this->addOrderByDataForProperty( $result, $joinVariable, $orderByProperty );
                return $result;
        }

        protected function getNextVariable() {
                return 'v' . ( ++$this->m_variableCounter );
        }

        protected function addOrderByDataForProperty( SMWSparqlCondition &$sparqlCondition, $mainVariable, $orderByProperty, $diType = SMWDataItem::TYPE_NOTYPE ) {
                if ( is_null( $orderByProperty ) ) {
                        return;
                }

                if ( $diType == SMWDataItem::TYPE_NOTYPE ) {
                        $typeId = $orderByProperty->findPropertyTypeID();
                        $diType = SMWDataValueFactory::getDataItemId( $typeId );
                }

                $this->addOrderByData( $sparqlCondition, $mainVariable, $diType );
        }

        protected function addOrderByData( SMWSparqlCondition &$sparqlCondition, $mainVariable, $diType ) {
                if ( $diType == SMWDataItem::TYPE_WIKIPAGE ) {
                        $sparqlCondition->orderByVariable = $mainVariable . 'sk';
                        $skeyExpElement = SMWExporter::getSpecialPropertyResource( '_SKEY' );
                        $sparqlCondition->weakConditions = array( $sparqlCondition->orderByVariable =>
                              "?$mainVariable " . $skeyExpElement->getQName() . " ?{$sparqlCondition->orderByVariable} .\n" );
                } else {
                        $sparqlCondition->orderByVariable = $mainVariable;
                }
        }

        protected function addMissingOrderByConditions( SMWSparqlCondition &$sparqlCondition ) {
                foreach ( $this->m_sortkeys as $propkey => $order ) {
                        if ( !array_key_exists( $propkey, $sparqlCondition->orderVariables ) ) { // Find missing property to sort by.
                                if ( $propkey === '' ) { // order by result page sortkey
                                        $this->addOrderByData( $sparqlCondition, self::RESULT_VARIABLE, SMWDataItem::TYPE_WIKIPAGE );
                                        $sparqlCondition->orderVariables[$propkey] = $sparqlCondition->orderByVariable;
                                } else { // extend query to order by other property values
                                        $diProperty = new SMWDIProperty( $propkey );
                                        $auxDescription = new SMWSomeProperty( $diProperty, new SMWThingDescription() );
                                        $auxSparqlCondition = $this->buildSparqlCondition( $auxDescription, self::RESULT_VARIABLE, null );
                                        // orderVariables MUST be set for $propkey -- or there is a bug; let it show!
                                        $sparqlCondition->orderVariables[$propkey] = $auxSparqlCondition->orderVariables[$propkey];
                                        $sparqlCondition->weakConditions[$sparqlCondition->orderVariables[$propkey]] = $auxSparqlCondition->getWeakConditionString() . $auxSparqlCondition->getCondition();
                                }
                        }
                }
        }

        protected function getSparqlOptions( SMWQuery $query, SMWSparqlCondition $sparqlCondition ) {
                global $smwgQSortingSupport, $smwgQRandSortingSupport;

                $result = array( 'LIMIT' => $query->getLimit() + 1, 'OFFSET' => $query->getOffset() );

                // Build ORDER BY options using discovered sorting fields.
                if ( $smwgQSortingSupport ) {
                        $orderByString = '';
                        foreach ( $this->m_sortkeys as $propkey => $order ) {
                                if ( ( $order != 'RANDOM' ) && array_key_exists( $propkey, $sparqlCondition->orderVariables ) ) {
                                        $orderByString .= "$order(?" . $sparqlCondition->orderVariables[$propkey] . ") ";
                                } elseif ( ( $order == 'RANDOM' ) && $smwgQRandSortingSupport ) {
                                        // not supported in SPARQL; might be possible via function calls in some stores
                                }
                        }
                        if ( $orderByString !== '' ) {
                                $result['ORDER BY'] = $orderByString;
                        }
                }
                return $result;
        }

}

---