ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-06-16 22:28:15 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Vault Query API parameter rename to aid clarity (#1627)

Browse Source 
* Vault Query API `contractType` renamed to `contractStateType` for clarity.

* Vault Query API `contractType` renamed to `contractStateType` for clarity.

* Vault Query Criteria attribute `CONTRACT_TYPE` renamed to `CONTRACT_STATE_TYPE` for clarity.

* All references to `contractType` renamed to `contractStateType` for clarity.
This commit is contained in:
josecoll
2017-09-25 16:02:32 +01:00
committed by GitHub
parent 39bc25e74d
commit 7b59f80bb3
10 changed files with 75 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
View File

@ -54,9 +54,9 @@ class CordaRPCOpsImpl(
override fun <T : ContractState> vaultQueryBy(criteria: QueryCriteria,
paging: PageSpecification,
sorting: Sort,
contractType: Class<out T>): Vault.Page<T> {
contractStateType: Class<out T>): Vault.Page<T> {
return database.transaction {
services.vaultQueryService._queryBy(criteria, paging, sorting, contractType)
services.vaultQueryService._queryBy(criteria, paging, sorting, contractStateType)
}
}
@ -64,9 +64,9 @@ class CordaRPCOpsImpl(
override fun <T : ContractState> vaultTrackBy(criteria: QueryCriteria,
paging: PageSpecification,
sorting: Sort,
contractType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
return database.transaction {
services.vaultQueryService._trackBy(criteria, paging, sorting, contractType)
services.vaultQueryService._trackBy(criteria, paging, sorting, contractStateType)
}
}

24
node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
View File

@ -21,8 +21,8 @@ import javax.persistence.Tuple
import javax.persistence.criteria.*
class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
val contractTypeMappings: Map<String, Set<String>>,
class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractState>,
val contractStateTypeMappings: Map<String, Set<String>>,
val criteriaBuilder: CriteriaBuilder,
val criteriaQuery: CriteriaQuery<Tuple>,
val vaultStates: Root<VaultSchemaV1.VaultStates>) : IQueryCriteriaParser {
@ -90,11 +90,11 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
return predicateSet
}
private fun deriveContractTypes(contractStateTypes: Set<Class<out ContractState>>? = null): Set<String> {
log.trace { "Contract types to be derived: primary ($contractType), additional ($contractStateTypes)" }
val combinedContractStateTypes = contractStateTypes?.plus(contractType) ?: setOf(contractType)
private fun deriveContractStateTypes(contractStateTypes: Set<Class<out ContractState>>? = null): Set<String> {
log.trace { "Contract types to be derived: primary ($contractStateType), additional ($contractStateTypes)" }
val combinedContractStateTypes = contractStateTypes?.plus(contractStateType) ?: setOf(contractStateType)
combinedContractStateTypes.filter { it.name != ContractState::class.java.name }.let {
val interfaces = it.flatMap { contractTypeMappings[it.name] ?: setOf(it.name) }
val interfaces = it.flatMap { contractStateTypeMappings[it.name] ?: setOf(it.name) }
val concrete = it.filter { !it.isInterface }.map { it.name }
log.trace { "Derived contract types: ${interfaces.union(concrete)}" }
return interfaces.union(concrete)
@ -395,17 +395,17 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
}
// contract state types
val contractTypes = deriveContractTypes(criteria.contractStateTypes)
if (contractTypes.isNotEmpty()) {
val contractStateTypes = deriveContractStateTypes(criteria.contractStateTypes)
if (contractStateTypes.isNotEmpty()) {
val predicateID = Pair(VaultSchemaV1.VaultStates::contractStateClassName.name, CollectionOperator.IN)
if (commonPredicates.containsKey(predicateID)) {
val existingTypes = (commonPredicates[predicateID]!!.expressions[0] as InPredicate<*>).values.map { (it as LiteralExpression).literal }.toSet()
if (existingTypes != contractTypes) {
log.warn("Enriching previous attribute [${VaultSchemaV1.VaultStates::contractStateClassName.name}] values [$existingTypes] with [$contractTypes]")
commonPredicates.replace(predicateID, criteriaBuilder.and(vaultStates.get<String>(VaultSchemaV1.VaultStates::contractStateClassName.name).`in`(contractTypes.plus(existingTypes))))
if (existingTypes != contractStateTypes) {
log.warn("Enriching previous attribute [${VaultSchemaV1.VaultStates::contractStateClassName.name}] values [$existingTypes] with [$contractStateTypes]")
commonPredicates.replace(predicateID, criteriaBuilder.and(vaultStates.get<String>(VaultSchemaV1.VaultStates::contractStateClassName.name).`in`(contractStateTypes.plus(existingTypes))))
}
} else {
commonPredicates.put(predicateID, criteriaBuilder.and(vaultStates.get<String>(VaultSchemaV1.VaultStates::contractStateClassName.name).`in`(contractTypes)))
commonPredicates.put(predicateID, criteriaBuilder.and(vaultStates.get<String>(VaultSchemaV1.VaultStates::contractStateClassName.name).`in`(contractStateTypes)))
}
}

20
node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
View File

@ -41,18 +41,18 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
* Maintain a list of contract state interfaces to concrete types stored in the vault
* for usage in generic queries of type queryBy<LinearState> or queryBy<FungibleState<*>>
*/
private val contractTypeMappings = bootstrapContractStateTypes()
private val contractStateTypeMappings = bootstrapContractStateTypes()
init {
vault.rawUpdates.subscribe { update ->
update.produced.forEach {
val concreteType = it.state.data.javaClass
log.trace { "State update of type: $concreteType" }
val seen = contractTypeMappings.any { it.value.contains(concreteType.name) }
val seen = contractStateTypeMappings.any { it.value.contains(concreteType.name) }
if (!seen) {
val contractInterfaces = deriveContractInterfaces(concreteType)
contractInterfaces.map {
val contractInterface = contractTypeMappings.getOrPut(it.name, { mutableSetOf() })
val contractInterface = contractStateTypeMappings.getOrPut(it.name, { mutableSetOf() })
contractInterface.add(concreteType.name)
}
}
@ -61,8 +61,8 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
}
@Throws(VaultQueryException::class)
override fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractType: Class<out T>): Vault.Page<T> {
log.info("Vault Query for contract type: $contractType, criteria: $criteria, pagination: $paging, sorting: $sorting")
override fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> {
log.info("Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting")
// refresh to include any schemas registered after initial VQ service initialisation
sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
@ -73,7 +73,7 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
if (!paging.isDefault) {
val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
val countCriteria = VaultCustomQueryCriteria(count, Vault.StateStatus.ALL)
val results = queryBy(contractType, criteria.and(countCriteria))
val results = queryBy(contractStateType, criteria.and(countCriteria))
totalStates = results.otherResults[0] as Long
}
@ -84,7 +84,7 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
val queryRootVaultStates = criteriaQuery.from(VaultSchemaV1.VaultStates::class.java)
// TODO: revisit (use single instance of parser for all queries)
val criteriaParser = HibernateQueryCriteriaParser(contractType, contractTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates)
val criteriaParser = HibernateQueryCriteriaParser(contractStateType, contractStateTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates)
try {
// parse criteria and build where predicates
@ -150,11 +150,11 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
private val mutex = ThreadBox({ vault.updatesPublisher })
@Throws(VaultQueryException::class)
override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
return mutex.locked {
val snapshotResults = _queryBy(criteria, paging, sorting, contractType)
val snapshotResults = _queryBy(criteria, paging, sorting, contractStateType)
@Suppress("UNCHECKED_CAST")
val updates = vault.updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractType, snapshotResults.stateTypes) } as Observable<Vault.Update<T>>
val updates = vault.updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) } as Observable<Vault.Update<T>>
DataFeed(snapshotResults, updates)
}
}

9
node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt
View File

@ -11,11 +11,9 @@ import net.corda.core.node.ServiceHub
import net.corda.core.node.services.StatesNotAvailableException
import net.corda.core.node.services.Vault
import net.corda.core.node.services.VaultService
import net.corda.core.node.services.vault.IQueryCriteriaParser
import net.corda.core.node.services.vault.QueryCriteria
import net.corda.core.node.services.vault.Sort
import net.corda.core.node.services.vault.SortAttribute
import net.corda.core.schemas.PersistentState
import net.corda.core.schemas.PersistentStateRef
import net.corda.core.serialization.SerializationDefaults.STORAGE_CONTEXT
import net.corda.core.serialization.SingletonSerializeAsToken
@ -34,7 +32,6 @@ import rx.subjects.PublishSubject
import java.security.PublicKey
import java.time.Instant
import java.util.*
import javax.persistence.criteria.Predicate
/**
* Currently, the node vault service is a very simple RDBMS backed implementation. It will change significantly when
@ -339,7 +336,7 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
override fun <T : FungibleAsset<U>, U : Any> tryLockFungibleStatesForSpending(lockId: UUID,
eligibleStatesQuery: QueryCriteria,
amount: Amount<U>,
contractType: Class<out T>): List<StateAndRef<T>> {
contractStateType: Class<out T>): List<StateAndRef<T>> {
if (amount.quantity == 0L) {
return emptyList()
}
@ -348,9 +345,9 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
val sortAttribute = SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF)
val sorter = Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC)))
val enrichedCriteria = QueryCriteria.VaultQueryCriteria(
contractStateTypes = setOf(contractType),
contractStateTypes = setOf(contractStateType),
softLockingCondition = QueryCriteria.SoftLockingCondition(QueryCriteria.SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(lockId)))
val results = services.vaultQueryService.queryBy(contractType, enrichedCriteria.and(eligibleStatesQuery), sorter)
val results = services.vaultQueryService.queryBy(contractStateType, enrichedCriteria.and(eligibleStatesQuery), sorter)
var claimedAmount = 0L
val claimedStates = mutableListOf<StateAndRef<T>>()

2
node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
View File

@ -1091,7 +1091,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
database.transaction {
val sortCol1 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONTRACT_TYPE), Sort.Direction.DESC)
val sortCol1 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONTRACT_STATE_TYPE), Sort.Direction.DESC)
val sortCol2 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.STATE_STATUS), Sort.Direction.ASC)
val sortCol3 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONSUMED_TIME), Sort.Direction.DESC)
val sorting = Sort(setOf(sortCol1, sortCol2, sortCol3))