io.prestosql.spi.transaction.IsolationLevel Java Examples

private static Connector createTestSessionConnector()
{
    return new Connector()
    {
        @Override
        public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
        {
            return new ConnectorTransactionHandle() {};
        }

        @Override
        public ConnectorMetadata getMetadata(ConnectorTransactionHandle transaction)
        {
            return new SystemTablesMetadata(new StaticSystemTablesProvider(ImmutableSet.of()));
        }
    };
}
 

public TransactionInfo(
        TransactionId transactionId,
        IsolationLevel isolationLevel,
        boolean readOnly,
        boolean autoCommitContext,
        DateTime createTime,
        Duration idleTime,
        List<CatalogName> catalogNames,
        Optional<CatalogName> writtenConnectorId)
{
    this.transactionId = requireNonNull(transactionId, "transactionId is null");
    this.isolationLevel = requireNonNull(isolationLevel, "isolationLevel is null");
    this.readOnly = readOnly;
    this.autoCommitContext = autoCommitContext;
    this.createTime = requireNonNull(createTime, "createTime is null");
    this.idleTime = requireNonNull(idleTime, "idleTime is null");
    this.catalogNames = ImmutableList.copyOf(requireNonNull(catalogNames, "connectorIds is null"));
    this.writtenConnectorId = requireNonNull(writtenConnectorId, "writtenConnectorId is null");
}
 

@Test
public void testStartTransactionExplicitModes()
{
    Session session = sessionBuilder()
            .setClientTransactionSupport()
            .build();
    TransactionManager transactionManager = createTestTransactionManager();
    QueryStateMachine stateMachine = createQueryStateMachine("START TRANSACTION", session, transactionManager);
    assertFalse(stateMachine.getSession().getTransactionId().isPresent());

    getFutureValue(new StartTransactionTask().execute(
            new StartTransaction(ImmutableList.of(new Isolation(Isolation.Level.SERIALIZABLE), new TransactionAccessMode(true))),
            transactionManager,
            metadata,
            new AllowAllAccessControl(),
            stateMachine,
            emptyList()));
    assertFalse(stateMachine.getQueryInfo(Optional.empty()).isClearTransactionId());
    assertTrue(stateMachine.getQueryInfo(Optional.empty()).getStartedTransactionId().isPresent());
    assertEquals(transactionManager.getAllTransactionInfos().size(), 1);

    TransactionInfo transactionInfo = transactionManager.getTransactionInfo(stateMachine.getQueryInfo(Optional.empty()).getStartedTransactionId().get());
    assertEquals(transactionInfo.getIsolationLevel(), IsolationLevel.SERIALIZABLE);
    assertTrue(transactionInfo.isReadOnly());
    assertFalse(transactionInfo.isAutoCommitContext());
}
 

@Override
public Connector create(String catalogName, Map<String, String> config, ConnectorContext context)
{
    int splitsPerNode = getSplitsPerNode(config);
    NodeManager nodeManager = context.getNodeManager();
    return new Connector()
    {
        @Override
        public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
        {
            return TpcdsTransactionHandle.INSTANCE;
        }

        @Override
        public ConnectorMetadata getMetadata(ConnectorTransactionHandle transactionHandle)
        {
            return new TpcdsMetadata();
        }

        @Override
        public ConnectorSplitManager getSplitManager()
        {
            return new TpcdsSplitManager(nodeManager, splitsPerNode, isWithNoSexism(config));
        }

        @Override
        public ConnectorRecordSetProvider getRecordSetProvider()
        {
            return new TpcdsRecordSetProvider();
        }

        @Override
        public ConnectorNodePartitioningProvider getNodePartitioningProvider()
        {
            return new TpcdsNodePartitioningProvider(nodeManager, splitsPerNode);
        }
    };
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_UNCOMMITTED, isolationLevel);
    MongoTransactionHandle transaction = new MongoTransactionHandle();
    transactions.put(transaction, new MongoMetadata(mongoSession));
    return transaction;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    RaptorTransactionHandle transaction = new RaptorTransactionHandle();
    transactions.put(transaction, metadataFactory.create(tableId -> beginDelete(tableId, transaction.getUuid())));
    return transaction;
}
 

private static Connector createTestingConnector()
{
    return new Connector()
    {
        private final ConnectorMetadata metadata = new TestingMetadata();

        @Override
        public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
        {
            return new ConnectorTransactionHandle() {};
        }

        @Override
        public ConnectorMetadata getMetadata(ConnectorTransactionHandle transaction)
        {
            return metadata;
        }

        @Override
        public List<PropertyMetadata<?>> getAnalyzeProperties()
        {
            return ImmutableList.of(
                    stringProperty("p1", "test string property", "", false),
                    integerProperty("p2", "test integer property", 0, false));
        }
    };
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    ConnectorTransactionHandle transaction = new HiveTransactionHandle();
    try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(getClass().getClassLoader())) {
        transactionManager.put(transaction, metadataFactory.create());
    }
    return transaction;
}
 

@Override
public TransactionId beginTransaction(IsolationLevel isolationLevel, boolean readOnly, boolean autoCommitContext)
{
    TransactionId transactionId = TransactionId.create();
    BoundedExecutor executor = new BoundedExecutor(finishingExecutor, maxFinishingConcurrency);
    TransactionMetadata transactionMetadata = new TransactionMetadata(transactionId, isolationLevel, readOnly, autoCommitContext, catalogManager, executor);
    checkState(transactions.put(transactionId, transactionMetadata) == null, "Duplicate transaction ID: %s", transactionId);
    return transactionId;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    log.debug("beginTransaction(isolationLevel=%s, readOnly=%s)", isolationLevel, readOnly);
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    return BigQueryTransactionHandle.INSTANCE;
}
 

public TransactionMetadata(
        TransactionId transactionId,
        IsolationLevel isolationLevel,
        boolean readOnly,
        boolean autoCommitContext,
        CatalogManager catalogManager,
        Executor finishingExecutor)
{
    this.transactionId = requireNonNull(transactionId, "transactionId is null");
    this.isolationLevel = requireNonNull(isolationLevel, "isolationLevel is null");
    this.readOnly = readOnly;
    this.autoCommitContext = autoCommitContext;
    this.catalogManager = requireNonNull(catalogManager, "catalogManager is null");
    this.finishingExecutor = listeningDecorator(ExecutorServiceAdapter.from(requireNonNull(finishingExecutor, "finishingExecutor is null")));
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    JdbcTransactionHandle transaction = new JdbcTransactionHandle();
    transactions.put(transaction, jdbcMetadataFactory.create());
    return transaction;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_UNCOMMITTED, isolationLevel);
    ConnectorTransactionHandle transaction = new AccumuloTransactionHandle();
    transactions.put(transaction, metadataFactory.create());
    return transaction;
}
 

@Override
public ListenableFuture<?> execute(StartTransaction statement, TransactionManager transactionManager, Metadata metadata, AccessControl accessControl, QueryStateMachine stateMachine, List<Expression> parameters)
{
    Session session = stateMachine.getSession();
    if (!session.isClientTransactionSupport()) {
        throw new PrestoException(StandardErrorCode.INCOMPATIBLE_CLIENT, "Client does not support transactions");
    }
    if (session.getTransactionId().isPresent()) {
        throw new PrestoException(StandardErrorCode.NOT_SUPPORTED, "Nested transactions not supported");
    }

    Optional<IsolationLevel> isolationLevel = extractIsolationLevel(statement);
    Optional<Boolean> readOnly = extractReadOnly(statement);

    TransactionId transactionId = transactionManager.beginTransaction(
            isolationLevel.orElse(TransactionManager.DEFAULT_ISOLATION),
            readOnly.orElse(TransactionManager.DEFAULT_READ_ONLY),
            false);

    stateMachine.setStartedTransactionId(transactionId);

    // Since the current session does not contain this new transaction ID, we need to manually mark it as inactive
    // when this statement completes.
    transactionManager.trySetInactive(transactionId);

    return immediateFuture(null);
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_UNCOMMITTED, isolationLevel);
    ConnectorTransactionHandle transaction = new HiveTransactionHandle();
    try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(classLoader)) {
        transactionManager.put(transaction, metadataFactory.create());
    }
    return transaction;
}
 

private static Optional<IsolationLevel> extractIsolationLevel(StartTransaction startTransaction)
{
    if (startTransaction.getTransactionModes().stream()
            .filter(Isolation.class::isInstance)
            .count() > 1) {
        throw semanticException(SYNTAX_ERROR, startTransaction, "Multiple transaction isolation levels specified");
    }

    return startTransaction.getTransactionModes().stream()
            .filter(Isolation.class::isInstance)
            .map(Isolation.class::cast)
            .map(Isolation::getLevel)
            .map(StartTransactionTask::convertLevel)
            .findFirst();
}
 

private static IsolationLevel convertLevel(Isolation.Level level)
{
    switch (level) {
        case SERIALIZABLE:
            return IsolationLevel.SERIALIZABLE;
        case REPEATABLE_READ:
            return IsolationLevel.REPEATABLE_READ;
        case READ_COMMITTED:
            return IsolationLevel.READ_COMMITTED;
        case READ_UNCOMMITTED:
            return IsolationLevel.READ_UNCOMMITTED;
        default:
            throw new AssertionError("Unhandled isolation level: " + level);
    }
}
 

@Override
public TransactionInfo getTransactionInfo(TransactionId transactionId)
{
    checkArgument(transactions.containsKey(transactionId), "Unknown transaction");
    return new TransactionInfo(
            transactionId,
            IsolationLevel.READ_UNCOMMITTED,
            false, //read only
            false, // auto commit
            DateTime.now(), // created
            Duration.succinctNanos(0), // idle
            ImmutableList.of(), // catalogs
            Optional.empty()); // write catalog
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    return new ConnectorTransactionHandle() {};
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    return ElasticsearchTransactionHandle.INSTANCE;
}
 

@Override
public TransactionId beginTransaction(IsolationLevel isolationLevel, boolean readOnly, boolean autoCommitContext)
{
    return beginTransaction(autoCommitContext);
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    return MemoryTransactionHandle.INSTANCE;
}
 

@Override
public Connector create(String catalogName, Map<String, String> properties, ConnectorContext context)
{
    int splitsPerNode = getSplitsPerNode(properties);
    ColumnNaming columnNaming = ColumnNaming.valueOf(properties.getOrDefault(TPCH_COLUMN_NAMING_PROPERTY, ColumnNaming.SIMPLIFIED.name()).toUpperCase());
    NodeManager nodeManager = context.getNodeManager();

    return new Connector()
    {
        @Override
        public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
        {
            return TpchTransactionHandle.INSTANCE;
        }

        @Override
        public ConnectorMetadata getMetadata(ConnectorTransactionHandle transaction)
        {
            return new TpchMetadata(columnNaming, predicatePushdownEnabled, partitioningEnabled);
        }

        @Override
        public ConnectorSplitManager getSplitManager()
        {
            return new TpchSplitManager(nodeManager, splitsPerNode);
        }

        @Override
        public ConnectorPageSourceProvider getPageSourceProvider()
        {
            if (isProducePages(properties)) {
                return new TpchPageSourceProvider(getMaxRowsPerPage(properties));
            }

            throw new UnsupportedOperationException();
        }

        @Override
        public ConnectorRecordSetProvider getRecordSetProvider()
        {
            if (!isProducePages(properties)) {
                return new TpchRecordSetProvider();
            }

            throw new UnsupportedOperationException();
        }

        @Override
        public ConnectorNodePartitioningProvider getNodePartitioningProvider()
        {
            return new TpchNodePartitioningProvider(nodeManager, splitsPerNode);
        }
    };
}
 

@Override
public ConnectorTransactionHandle beginTransaction(TransactionId transactionId, IsolationLevel isolationLevel, boolean readOnly)
{
    return new GlobalSystemTransactionHandle(transactionId);
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    return ThriftTransactionHandle.INSTANCE;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    return LocalFileTransactionHandle.INSTANCE;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_UNCOMMITTED, isolationLevel);
    return CassandraTransactionHandle.INSTANCE;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    return KuduTransactionHandle.INSTANCE;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean b)
{
    checkConnectorSupports(READ_COMMITTED, isolationLevel);
    return KinesisTransactionHandle.INSTANCE;
}
 

@Override
public ConnectorTransactionHandle beginTransaction(IsolationLevel isolationLevel, boolean readOnly)
{
    return INSTANCE;
}