Examples with Transaction herddb.model.Transaction used on opensource projects

Example 41 with Transaction

use of herddb.model.Transaction in project herddb by diennea.

the class SecondaryUniqueIndexAccessSuite method secondaryUniqueIndexPrefixScan.

@Test
public void secondaryUniqueIndexPrefixScan() throws Exception {
    String nodeId = "localhost";
    Path tmp = tmpDir.newFolder().toPath();
    ServerConfiguration serverConfiguration = newServerConfigurationWithAutoPort(tmp);
    serverConfiguration.set(ServerConfiguration.PROPERTY_READLOCK_TIMEOUT, 3);
    serverConfiguration.set(ServerConfiguration.PROPERTY_WRITELOCK_TIMEOUT, 3);
    try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new MemoryDataStorageManager(), new MemoryCommitLogManager(), tmp, null, serverConfiguration, NullStatsLogger.INSTANCE)) {
        manager.start();
        CreateTableSpaceStatement st1 = new CreateTableSpaceStatement("tblspace1", Collections.singleton(nodeId), nodeId, 1, 0, 0);
        manager.executeStatement(st1, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
        manager.waitForTablespace("tblspace1", 10000);
        Table table = Table.builder().tablespace("tblspace1").name("t1").column("id", ColumnTypes.STRING).column("n1", ColumnTypes.INTEGER).column("name", ColumnTypes.STRING).primaryKey("id").build();
        CreateTableStatement st2 = new CreateTableStatement(table);
        manager.executeStatement(st2, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
        Index index = Index.builder().onTable(table).type(Index.TYPE_HASH).unique(true).column("n1", ColumnTypes.INTEGER).column("name", ColumnTypes.STRING).build();
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('a',1,'n1')", Collections.emptyList());
        // create index, it will be built using existing data
        CreateIndexStatement st3 = new CreateIndexStatement(index);
        manager.executeStatement(st3, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
        // cannot insert another record with '1-n1'
        herddb.utils.TestUtils.assertThrows(UniqueIndexContraintViolationException.class, () -> {
            TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('b',1,'n1')", Collections.emptyList());
        });
        // multiple values
        // it is not a transaction, the first INSERT will succeed
        herddb.utils.TestUtils.assertThrows(UniqueIndexContraintViolationException.class, () -> {
            TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('b',8,'n1'),('c',1,'n1')", Collections.emptyList());
        });
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('d',2,'n2')", Collections.emptyList());
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('e',3,'n2')", Collections.emptyList());
        // single record UPDATE
        herddb.utils.TestUtils.assertThrows(UniqueIndexContraintViolationException.class, () -> {
            TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=1,name='n1' where id='d'", Collections.emptyList());
        });
        // multi record UPDATE
        herddb.utils.TestUtils.assertThrows(UniqueIndexContraintViolationException.class, () -> {
            TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=1,name='n1' where id='d'", Collections.emptyList());
        });
        {
            TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1 WHERE n1=1", Collections.emptyList(), true, true, false, -1);
            ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
            assertTrue(scan.getPredicate().getIndexOperation() instanceof SecondaryIndexPrefixScan);
            try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
                assertEquals(1, scan1.consume().size());
            }
        }
        {
            TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1 WHERE n1=8", Collections.emptyList(), true, true, false, -1);
            ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
            assertTrue(scan.getPredicate().getIndexOperation() instanceof SecondaryIndexPrefixScan);
            try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
                assertEquals(1, scan1.consume().size());
            }
        }
        {
            TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1 WHERE n1=2 and name='n2'", Collections.emptyList(), true, true, false, -1);
            ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
            assertTrue(scan.getPredicate().getIndexOperation() instanceof SecondaryIndexSeek);
            try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
                assertEquals(1, scan1.consume().size());
            }
        }
        {
            TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1 WHERE n1>=1", Collections.emptyList(), true, true, false, -1);
            ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
            assertNull(scan.getPredicate().getIndexOperation());
            try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
                assertEquals(4, scan1.consume().size());
            }
        }
        // update the index
        TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=10,name='n1' where id='a'", Collections.emptyList());
        TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=1,name='n1' where id='d'", Collections.emptyList());
        {
            TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1 WHERE n1=1", Collections.emptyList(), true, true, false, -1);
            ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
            assertTrue(scan.getPredicate().getIndexOperation() instanceof SecondaryIndexPrefixScan);
            try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
                List<DataAccessor> consume = scan1.consume();
                assertEquals(1, consume.size());
                assertEquals(RawString.of("d"), consume.get(0).get("id"));
            }
        }
        // delete, update the index
        TestUtils.executeUpdate(manager, "DELETE FROM tblspace1.t1 where id='d'", Collections.emptyList());
        // enure another record can be stored on the same key
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('o',1,'n1')", Collections.emptyList());
        // test transactions
        long tx = TestUtils.beginTransaction(manager, "tblspace1");
        // insert a new record, and a new index entry, but in transaction, the transacition will hold the index lock on "100-n100"
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('t1',100,'n100')", Collections.emptyList(), new TransactionContext(tx));
        Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
        assertEquals(1, transaction.locks.get("t1_n1_name").size());
        // delete the same record, the index still hasn't been touched, but we are still holding a lock on "100-n100"
        TestUtils.executeUpdate(manager, "DELETE FROM  tblspace1.t1 where id='t1'", Collections.emptyList(), new TransactionContext(tx));
        // insert a new record again, with the same key in the index, we are still holding the lock on "100-n100"
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('t2',100,'n100')", Collections.emptyList(), new TransactionContext(tx));
        // check that we are going to timeout on lock acquisition from another context (for instance no transaction)
        StatementExecutionException err = herddb.utils.TestUtils.expectThrows(StatementExecutionException.class, () -> {
            TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('t3',100,'n100')", Collections.emptyList());
        });
        assertThat(err.getCause(), instanceOf(LockAcquireTimeoutException.class));
        TestUtils.commitTransaction(manager, "tblspace1", tx);
        // cannot insert another record with "100-n100"
        herddb.utils.TestUtils.assertThrows(UniqueIndexContraintViolationException.class, () -> {
            TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('t3',100,'n100')", Collections.emptyList());
        });
        // again, with transactions, use 200-n200 as index key
        tx = TestUtils.beginTransaction(manager, "tblspace1");
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('s1',200,'n200')", Collections.emptyList(), new TransactionContext(tx));
        // touching the same record, lock has been already held by the transaction
        TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=200 where n1=200", Collections.emptyList(), new TransactionContext(tx));
        TestUtils.commitTransaction(manager, "tblspace1", tx);
        // again, lock the 200-n200 key with a fake update
        tx = TestUtils.beginTransaction(manager, "tblspace1");
        assertEquals(1, TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=200 where n1=200", Collections.emptyList(), new TransactionContext(tx)).getUpdateCount());
        // timeout during an update, lock for 200-n200 is on the transaction, can't perform the same update from another context
        err = herddb.utils.TestUtils.expectThrows(StatementExecutionException.class, () -> {
            TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=200 where n1=200", Collections.emptyList());
        });
        assertThat(err.getCause(), instanceOf(LockAcquireTimeoutException.class));
        assertEquals(1, TestUtils.executeUpdate(manager, "DELETE FROM tblspace1.t1 where n1=200", Collections.emptyList(), new TransactionContext(tx)).getUpdateCount());
        TestUtils.commitTransaction(manager, "tblspace1", tx);
        TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,name) values('s1',200,'n200')", Collections.emptyList());
        // select "FOR UPDATE" does not create locks for the index
        tx = TestUtils.beginTransaction(manager, "tblspace1");
        assertEquals(1, TestUtils.scan(manager, "SELECT * FROM tblspace1.t1 where n1=200 FOR UPDATE", Collections.emptyList(), new TransactionContext(tx)).consumeAndClose().size());
        transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
        assertNull(transaction.locks.get("t1_n1_name"));
        // but it creates a lock for the primary key
        assertEquals(1, transaction.locks.get("t1").size());
        assertEquals(1, TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=200 where n1=200", Collections.emptyList(), new TransactionContext(tx)).getUpdateCount());
        // now we have the lock on the unique index
        assertEquals(1, transaction.locks.get("t1_n1_name").size());
        // still holding the lock for the primary key
        assertEquals(1, transaction.locks.get("t1").size());
        // timeout during an update, lock for 200-n200 is on the transaction, can't perform the same update from another context
        err = herddb.utils.TestUtils.expectThrows(StatementExecutionException.class, () -> {
            TestUtils.executeUpdate(manager, "UPDATE tblspace1.t1 set n1=200, name='n200' where id='t2'", Collections.emptyList());
        });
        assertThat(err.getCause(), instanceOf(LockAcquireTimeoutException.class));
        TestUtils.commitTransaction(manager, "tblspace1", tx);
    }
}

Example 42 with Transaction

use of herddb.model.Transaction in project herddb by diennea.

the class TableSpaceDumpFileWriter method receiveTransactionsAtDump.

@Override
public void receiveTransactionsAtDump(List<Transaction> entries) throws DataStorageManagerException {
    try {
        out.writeUTF(BackupFileConstants.ENTRY_TYPE_TRANSACTIONS);
        out.writeVInt(entries.size());
        for (Transaction entry : entries) {
            out.writeArray(entry.serialize());
        }
    } catch (IOException err) {
        throw new DataStorageManagerException(err);
    }
    listener.log("receivetransactions", "dumped " + entries.size() + " txentries", Collections.singletonMap("count", entries.size()));
}

Example 43 with Transaction

use of herddb.model.Transaction in project herddb by diennea.

the class RawSQLTest method selectForUpdate.

@Test
public void selectForUpdate() throws Exception {
    String nodeId = "localhost";
    try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new MemoryDataStorageManager(), new MemoryCommitLogManager(), null, null)) {
        manager.start();
        CreateTableSpaceStatement st1 = new CreateTableSpaceStatement("tblspace1", Collections.singleton(nodeId), nodeId, 1, 0, 0);
        manager.executeStatement(st1, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
        manager.waitForTablespace("tblspace1", 10000);
        execute(manager, "CREATE TABLE tblspace1.tsql (k1 string primary key, n1 int)", Collections.emptyList());
        execute(manager, "INSERT INTO tblspace1.tsql (k1,n1) values(?,?)", Arrays.asList("a", 1));
        // GET .. FOR UPDATE -> WRITE LOCK
        {
            long tx;
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a' FOR UPDATE", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertTrue(lock.write);
            commitTransaction(manager, "tblspace1", tx);
        }
        // GET .. -> READ LOCK
        {
            long tx;
            try (DataScanner scan = scanKeepReadLocks(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a'", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertFalse(lock.write);
            commitTransaction(manager, "tblspace1", tx);
        }
        // GET .. -> NO READ LOCK BY DEFAULT
        {
            long tx = TestUtils.beginTransaction(manager, "tblspace1");
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a'", Collections.emptyList(), new TransactionContext(tx))) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNull(lock);
            commitTransaction(manager, "tblspace1", tx);
        }
        // SCAN .. FOR UPDATE -> WRITE LOCK
        {
            long tx;
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql FOR UPDATE", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertTrue(lock.write);
            commitTransaction(manager, "tblspace1", tx);
        }
        // SCAN .. -> READ LOCK
        {
            long tx;
            try (DataScanner scan = scanKeepReadLocks(manager, "SELECT k1,n1 FROM tblspace1.tsql ", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertFalse(lock.write);
            commitTransaction(manager, "tblspace1", tx);
        }
        // SCAN .. -> NO READ LOCK by default
        {
            long tx = TestUtils.beginTransaction(manager, "tblspace1");
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql ", Collections.emptyList(), new TransactionContext(tx))) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNull(lock);
            commitTransaction(manager, "tblspace1", tx);
        }
        // test that locks are reentrant
        {
            long tx;
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a' FOR UPDATE", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertTrue(lock.write);
            long tx2;
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a' FOR UPDATE", Collections.emptyList(), new TransactionContext(tx))) {
                assertEquals(1, scan.consume().size());
                tx2 = scan.getTransactionId();
            }
            assertEquals(tx2, tx);
            Transaction transaction2 = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock2 = (herddb.utils.LockHandle) transaction2.locks.get("tsql").get(key);
            System.out.println("LOCK2: " + lock2);
            assertNotNull(lock2);
            assertSame(lock2, lock);
            commitTransaction(manager, "tblspace1", tx);
        }
        // test lock upgrade
        {
            long tx;
            try (DataScanner scan = scanKeepReadLocks(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a'", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION)) {
                assertEquals(1, scan.consume().size());
                tx = scan.getTransactionId();
            }
            Bytes key = Bytes.from_string("a");
            Transaction transaction = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock = (herddb.utils.LockHandle) transaction.locks.get("tsql").get(key);
            System.out.println("LOCK: " + lock);
            assertNotNull(lock);
            assertFalse(lock.write);
            long tx2;
            try (DataScanner scan = scan(manager, "SELECT k1,n1 FROM tblspace1.tsql where k1='a' FOR UPDATE", Collections.emptyList(), new TransactionContext(tx))) {
                assertEquals(1, scan.consume().size());
                tx2 = scan.getTransactionId();
            }
            assertEquals(tx2, tx);
            Transaction transaction2 = manager.getTableSpaceManager("tblspace1").getTransaction(tx);
            herddb.utils.LockHandle lock2 = (herddb.utils.LockHandle) transaction2.locks.get("tsql").get(key);
            System.out.println("LOCK2: " + lock2);
            assertNotNull(lock2);
            assertNotSame(lock2, lock);
            assertTrue(lock2.write);
            commitTransaction(manager, "tblspace1", tx);
        }
    }
}