scray.cassandra.configuration.CassandraQueryspaceConfiguration.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scray-cassandra Show documentation
scray adapter to r/w Cassandra column families
The newest version!
//// See the LICENCE.txt file distributed with this work for additional
//// information regarding copyright ownership.
////
//// Licensed under the Apache License, Version 2.0 (the "License");
//// you may not use this file except in compliance with the License.
//// You may obtain a copy of the License at
////
//// http://www.apache.org/licenses/LICENSE-2.0
////
//// Unless required by applicable law or agreed to in writing, software
//// distributed under the License is distributed on an "AS IS" BASIS,
//// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//// See the License for the specific language governing permissions and
//// limitations under the License.
//package scray.cassandra.configuration
//
//import com.twitter.storehaus.cassandra.cql.AbstractCQLCassandraStore
//import com.twitter.storehaus.cassandra.cql.CQLCassandraCollectionStore
//import com.twitter.storehaus.cassandra.cql.CQLCassandraConfiguration.StoreSession
//import scray.querying.Query
//import scray.querying.Registry
//import scray.querying.planning.Planner
//import scray.querying.description.ColumnConfiguration
//import scray.querying.description.QueryspaceConfiguration
//import scray.cassandra.extractors.CassandraExtractor
//import scray.querying.description.Row
//import scray.querying.description.Column
//import scray.querying.source.indexing.IndexConfig
//import scray.querying.description.TableConfiguration
//import scray.querying.description.VersioningConfiguration
//import scray.querying.description.internal.MaterializedView
//import scray.querying.queries.DomainQuery
//import scray.querying.description.internal.SingleValueDomain
//import scray.querying.description.internal.RangeValueDomain
//import scala.annotation.tailrec
//import scray.querying.source.Splitter
//import scray.querying.sync.cassandra.CassandraDbSession
//
///**
// * configuration of a simple Cassandra-based query space.
// * If all tables used are based on Cassandra this class can be used out-of-the-box.
// * 
// * name is used to identify the new query space
// * tables is a list of Storehaus-Cassandra-stores you can use to query anything
// * indexes is a concrete list of things which are manually indexed
// * (auto-indexed columns are automatically detected for Cassandra)  
// */
//class CassandraQueryspaceConfiguration(
//    override val name: String,
//    val tables: Set[(AbstractCQLCassandraStore[_, _], ((_) => Row, Option[String], Option[VersioningConfiguration[_, _, _]]))],
//    // mapping from indexed table and the indexed column to the table containing the index and the ref column
//    indexes: Map[(AbstractCQLCassandraStore[_, _], String),
//      (AbstractCQLCassandraStore[_, _], String, IndexConfig, Option[Function1[_,_]], Set[String])],
//    splitters: Map[Column, Splitter[_]]
//) extends QueryspaceConfiguration(name) {
//  
//  lazy val tableRowMapperMap: Map[AbstractCQLCassandraStore[_, _], ((_) => Row, Option[String], Option[VersioningConfiguration[_, _, _]])] = tables.toMap
//  
//  override def queryCanBeOrdered(query: DomainQuery): Option[ColumnConfiguration] = {
//    // TODO: maybe this is right for some cases, but we must implement all:
//    //   - what happens if the manual index is not going to be used
//    //   - what happens if the main query doesn't use the table with the clustering column 
//    query.getOrdering.flatMap { ordering =>
//      Registry.getQuerySpaceColumn(query.getQueryspace, query.querySpaceVersion, ordering.column).flatMap { colConfig =>
//        colConfig.index.flatMap(index => if(index.isManuallyIndexed.isDefined && index.isSorted) {
//          val itc = index.isManuallyIndexed.get.indexTableConfig()
//          if(itc.queryableStore.isDefined || (itc.versioned.isDefined && itc.versioned.get.runtimeVersion().isDefined )) {
//            Some(colConfig)
//          } else {
//            None
//          }
//        } else {
//          None
//        }).orElse {
//          Registry.getQuerySpaceTable(query.getQueryspace, query.querySpaceVersion, ordering.column.table).flatMap { table =>
//            if(table.clusteringKeyColumns.size > 0 && table.clusteringKeyColumns(0) == ordering.column ) {
//              Some(colConfig)
//            } else {
//              None
//            }
//          }
//        }
//      }
//    }
//  }
//  
//  override def queryCanBeGrouped(query: DomainQuery): Option[ColumnConfiguration] = queryCanBeOrdered(query)
//  
//  override def getColumns(version: Int): List[ColumnConfiguration] = tables.toList.flatMap ( table => {
//    val typeReducedTable = table._1.asInstanceOf[AbstractCQLCassandraStore[Any, Any]]
//    val extractor = CassandraExtractor.getExtractor(typeReducedTable, table._2._2, table._2._3, Some(CassandraExtractor.DB_ID))
//    val allColumns = extractor.getTableConfiguration(table._2._1).allColumns
//    allColumns.map { col =>
//      val index = extractor.createManualIndexConfiguration(col, name, version, typeReducedTable, indexes, tableRowMapperMap)
//      val cassSession = new CassandraDbSession(typeReducedTable.columnFamily.session.getSession)
//      extractor.getColumnConfiguration(cassSession, typeReducedTable.columnFamily.session.getKeyspacename, 
//          typeReducedTable.columnFamily.getPreparedNamed, col, this, index, splitters)
//    }
//  })
//  
//  override def getTables(version: Int): Set[TableConfiguration[_, _, _]] = tables.map ( table => {
//    val typeReducedTable = table._1.asInstanceOf[AbstractCQLCassandraStore[Any, Any]]
//    val extractor = CassandraExtractor.getExtractor(typeReducedTable, table._2._2, table._2._3, Some(CassandraExtractor.DB_ID))
//    extractor.getTableConfiguration(table._2._1)
//  })
//  
//  override def queryCanUseMaterializedView (query: DomainQuery, materializedView: MaterializedView): Option[(Boolean, Int)] = {
//    @tailrec def calculateSpecificity(cols: List[Column], count: Int, checkOrdering: Option[Column] = None): (Boolean, Int) = {
//      // returns true, specificity if view matches requested ordering
//      // returns false, specificity if the view cannot be used to order according to ordering
//      val single = query.getWhereAST.find { dom =>
//         cols.size > 0 && dom.column == cols.head && dom.isInstanceOf[SingleValueDomain[_]]
//      }.isDefined
//      // last can be a RangeValueDomain (and should be in case of checkOrdering != None)
//      if(!single) {
//        val rangeResult: List[Option[Boolean]] = query.getWhereAST.collect { 
//          case rvd: RangeValueDomain[_] if cols.size > 0 && rvd.column == cols.head => 
//            checkOrdering match {
//              case Some(orderedCol) => Some(orderedCol.columnName == cols.head) 
//              case None => None
//            }
//        }
//        if(rangeResult.size > 0) {
//          rangeResult.head match {
//            case Some(ord) => (ord, count + 1)
//            case None => (false, count + 1)
//          }
//        } else {
//          (false, count)          
//        }
//      } else {
//        calculateSpecificity(cols.tail, count + 1, checkOrdering)
//      }
//    }
//    def getClusteringMatches(): (Boolean, Int) = 
//      calculateSpecificity(materializedView.viewTable.clusteringKeyColumns, 0, query.getOrdering.map(_.column))
//    
//    // check that all primarykeyColumns are satisfied with SingleValueDomains
//    val partitionSatisfied = (materializedView.viewTable.primarykeyColumns.find ( col => query.getWhereAST.find { _ match {
//      case svd: SingleValueDomain[_] => col != svd.column
//      case _ => true
//    }}.isDefined).isEmpty, materializedView.viewTable.primarykeyColumns.size)
//
//    if(partitionSatisfied._1) {
//      // the weight is calculated
//      val clusteringMatches = getClusteringMatches
//      Some(clusteringMatches._1, partitionSatisfied._2 + clusteringMatches._2)
//    } else {
//      None
//    }
//  }
//  
//  /**
//   * reloads the query-space configuration
//   * TODO: invent some mechanism to do the reload 
//   */
//  override def reInitialize(oldversion: Int): QueryspaceConfiguration = this 
//}