use of herddb.sql.TranslatedQuery in project herddb by diennea.
the class BootAsNewLeaderTest method testLeaderOnlineLogNoMoreAvailableDataAlreadyPresentBootAsNewLeader.
@Test
public void testLeaderOnlineLogNoMoreAvailableDataAlreadyPresentBootAsNewLeader() throws Exception {
final AtomicInteger countErase = new AtomicInteger();
SystemInstrumentation.addListener(new SystemInstrumentation.SingleInstrumentationPointListener("eraseTablespaceData") {
@Override
public void acceptSingle(Object... args) throws Exception {
countErase.incrementAndGet();
}
});
ServerConfiguration serverconfig_1 = newServerConfigurationWithAutoPort(folder.newFolder().toPath());
serverconfig_1.set(ServerConfiguration.PROPERTY_NODEID, "server1");
serverconfig_1.set(ServerConfiguration.PROPERTY_MODE, ServerConfiguration.PROPERTY_MODE_CLUSTER);
serverconfig_1.set(ServerConfiguration.PROPERTY_ZOOKEEPER_ADDRESS, testEnv.getAddress());
serverconfig_1.set(ServerConfiguration.PROPERTY_ZOOKEEPER_PATH, testEnv.getPath());
serverconfig_1.set(ServerConfiguration.PROPERTY_ZOOKEEPER_SESSIONTIMEOUT, testEnv.getTimeout());
serverconfig_1.set(ServerConfiguration.PROPERTY_ENFORCE_LEADERSHIP, false);
serverconfig_1.set(ServerConfiguration.PROPERTY_BOOKKEEPER_LEDGERS_RETENTION_PERIOD, 1);
serverconfig_1.set(ServerConfiguration.PROPERTY_CHECKPOINT_PERIOD, 0);
// disabled
serverconfig_1.set(ServerConfiguration.PROPERTY_BOOKKEEPER_MAX_IDLE_TIME, 0);
ServerConfiguration serverconfig_2 = serverconfig_1.copy().set(ServerConfiguration.PROPERTY_NODEID, "server2").set(ServerConfiguration.PROPERTY_BASEDIR, folder.newFolder().toPath().toAbsolutePath());
Table table = Table.builder().name("t1").column("c", ColumnTypes.INTEGER).column("s", ColumnTypes.INTEGER).primaryKey("c").build();
Index index = Index.builder().onTable(table).type(Index.TYPE_BRIN).column("s", ColumnTypes.STRING).build();
try (Server server_1 = new Server(serverconfig_1)) {
server_1.start();
server_1.waitForStandaloneBoot();
server_1.getManager().executeStatement(new CreateTableStatement(table), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeStatement(new CreateIndexStatement(index), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 1, "s", "1")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 2, "s", "2")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 3, "s", "3")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 4, "s", "4")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().executeStatement(new AlterTableSpaceStatement(TableSpace.DEFAULT, new HashSet<>(Arrays.asList("server1", "server2")), "server1", 1, 0), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
TranslatedQuery translated = server_1.getManager().getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM " + TableSpace.DEFAULT + ".t1 WHERE s=1", Collections.emptyList(), true, true, false, -1);
ScanStatement statement = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(statement.getPredicate().getIndexOperation() instanceof SecondaryIndexSeek);
try (DataScanner scan = server_1.getManager().scan(statement, translated.context, TransactionContext.NO_TRANSACTION)) {
assertEquals(1, scan.consume().size());
}
}
String tableSpaceUUID;
try (Server server_1 = new Server(serverconfig_1)) {
server_1.start();
server_1.waitForStandaloneBoot();
{
ZookeeperMetadataStorageManager man = (ZookeeperMetadataStorageManager) server_1.getMetadataStorageManager();
tableSpaceUUID = man.describeTableSpace(TableSpace.DEFAULT).uuid;
LedgersInfo ledgersList = ZookeeperMetadataStorageManager.readActualLedgersListFromZookeeper(man.getZooKeeper(), testEnv.getPath() + "/ledgers", tableSpaceUUID);
assertEquals(2, ledgersList.getActiveLedgers().size());
}
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 5, "s", "5")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
server_1.getManager().checkpoint();
}
try (Server server_1 = new Server(serverconfig_1)) {
server_1.start();
server_1.waitForStandaloneBoot();
{
ZookeeperMetadataStorageManager man = (ZookeeperMetadataStorageManager) server_1.getMetadataStorageManager();
LedgersInfo ledgersList = ZookeeperMetadataStorageManager.readActualLedgersListFromZookeeper(man.getZooKeeper(), testEnv.getPath() + "/ledgers", tableSpaceUUID);
assertEquals(2, ledgersList.getActiveLedgers().size());
}
server_1.getManager().executeUpdate(new InsertStatement(TableSpace.DEFAULT, "t1", RecordSerializer.makeRecord(table, "c", 6, "s", "6")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
{
ZookeeperMetadataStorageManager man = (ZookeeperMetadataStorageManager) server_1.getMetadataStorageManager();
LedgersInfo ledgersList = ZookeeperMetadataStorageManager.readActualLedgersListFromZookeeper(man.getZooKeeper(), testEnv.getPath() + "/ledgers", tableSpaceUUID);
assertEquals(2, ledgersList.getActiveLedgers().size());
}
server_1.getManager().checkpoint();
}
assertEquals(0, countErase.get());
LogSequenceNumber server2checkpointPosition;
try (Server server_1 = new Server(serverconfig_1)) {
server_1.start();
server_1.waitForStandaloneBoot();
// start server_2, and flush data locally
try (Server server_2 = new Server(serverconfig_2)) {
server_2.start();
assertTrue(server_2.getManager().waitForTablespace(TableSpace.DEFAULT, 60000, false));
// wait for data to arrive on server_2
for (int i = 0; i < 100; i++) {
GetResult found = server_2.getManager().get(new GetStatement(TableSpace.DEFAULT, "t1", Bytes.from_int(1), null, false), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
if (found.found()) {
break;
}
Thread.sleep(100);
}
// force a checkpoint, data is flushed to disk
server_2.getManager().checkpoint();
server2checkpointPosition = server_2.getManager().getTableSpaceManager(TableSpace.DEFAULT).getLog().getLastSequenceNumber();
System.out.println("server2 checkpoint time: " + server2checkpointPosition);
}
}
// start again server_1, in order to create a new ledger
try (Server server_1 = new Server(serverconfig_1)) {
server_1.start();
server_1.waitForStandaloneBoot();
BookkeeperCommitLog ll = (BookkeeperCommitLog) server_1.getManager().getTableSpaceManager(TableSpace.DEFAULT).getLog();
// server_1 make much progress
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
ll.rollNewLedger();
// a checkpoint will delete old ledgers
server_1.getManager().checkpoint();
{
ZookeeperMetadataStorageManager man = (ZookeeperMetadataStorageManager) server_1.getMetadataStorageManager();
LedgersInfo ledgersList = ZookeeperMetadataStorageManager.readActualLedgersListFromZookeeper(man.getZooKeeper(), testEnv.getPath() + "/ledgers", tableSpaceUUID);
System.out.println("ledgerList: " + ledgersList);
assertEquals(1, ledgersList.getActiveLedgers().size());
assertTrue(!ledgersList.getActiveLedgers().contains(ledgersList.getFirstLedger()));
// we want to be sure that server_2 cannot recover from log
assertTrue(!ledgersList.getActiveLedgers().contains(server2checkpointPosition.ledgerId));
}
assertEquals(1, countErase.get());
// make server2 boot as leader, it will fence out server1
// but server1 is not writing so it won't know from BK
// it will see his new role from zookeeper (with a 'watch' notification)
server_1.getManager().executeStatement(new AlterTableSpaceStatement(TableSpace.DEFAULT, new HashSet<>(Arrays.asList("server1", "server2")), "server2", 1, 0), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
// trying to become leader
try (Server server_2 = new Server(serverconfig_2)) {
server_2.start();
assertFalse(server_2.getManager().waitForTablespace(TableSpace.DEFAULT, 10000, true));
}
// make server_1 leader again
server_1.getManager().executeStatement(new AlterTableSpaceStatement(TableSpace.DEFAULT, new HashSet<>(Arrays.asList("server1", "server2")), "server1", 1, 0), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
// now server_2 must be able to boot, downloading data from server_1 and easing local state
try (Server server_2 = new Server(serverconfig_2)) {
server_2.start();
assertFalse(server_2.getManager().waitForTablespace(TableSpace.DEFAULT, 60000, true));
}
// make server_2 leader again
server_1.getManager().executeStatement(new AlterTableSpaceStatement(TableSpace.DEFAULT, new HashSet<>(Arrays.asList("server1", "server2")), "server2", 1, 0), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
// stop server_1
server_1.close();
// it must have enough local data to boot
try (Server server_2 = new Server(serverconfig_2)) {
server_2.start();
assertTrue(server_2.getManager().waitForTablespace(TableSpace.DEFAULT, 60000, true));
}
}
}
use of herddb.sql.TranslatedQuery in project herddb by diennea.
the class PrimaryIndexScanRangeTest method primaryIndexPrefixScanFileTest.
@Test
public void primaryIndexPrefixScanFileTest() throws Exception {
Path dataPath = folder.newFolder("data").toPath();
String nodeId = "localhost";
try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new FileDataStorageManager(dataPath), 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);
Table table = Table.builder().tablespace("tblspace1").name("t1").column("n1", ColumnTypes.INTEGER).column("n2", ColumnTypes.INTEGER).column("id", ColumnTypes.STRING).column("name", ColumnTypes.STRING).primaryKey("n1").build();
CreateTableStatement st2 = new CreateTableStatement(table);
manager.executeStatement(st2, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('a',1,5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('b',2,5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('c',3,6,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('d',5,7,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('e',6,5,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('f',7,7,'n2')", Collections.emptyList());
performBasicPlannerTests(manager);
assertFalse(manager.getTableSpaceManager("tblspace1").getTableManager("t1").isKeyToPageSortedAscending());
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(3, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
assertEquals(6, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertNull(scan.getComparator());
assertNotNull(scan.getLimits());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(3, tuples.get(0).get("n1"));
assertEquals(6, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 1,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(3, tuples.get(0).get("n1"));
assertEquals(5, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 3,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(6, tuples.get(0).get("n1"));
assertEquals(7, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 4,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(1, tuples.size());
assertEquals(7, tuples.get(0).get("n1"));
}
}
// add a record in the middle of the sorted recordset
DMLStatementExecutionResult res = TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g',4,6,'n2')", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION);
long tx = res.transactionId;
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(4, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
assertEquals(4, tuples.get(2).get("n1"));
assertEquals(6, tuples.get(3).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(6, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
assertEquals(4, tuples.get(2).get("n1"));
assertEquals(5, tuples.get(3).get("n1"));
assertEquals(6, tuples.get(4).get("n1"));
assertEquals(7, tuples.get(5).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
for (DataAccessor tuple : tuples) {
System.out.println("tuple: " + tuple.toMap());
}
assertEquals(3, tuples.size());
assertEquals(3, tuples.get(0).get("n1"));
assertEquals(4, tuples.get(1).get("n1"));
assertEquals(5, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=6 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(3, tuples.size());
assertEquals(3, tuples.get(0).get("n1"));
assertEquals(4, tuples.get(1).get("n1"));
assertEquals(6, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 1,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(3, tuples.get(0).get("n1"));
assertEquals(4, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 3,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(5, tuples.get(0).get("n1"));
assertEquals(6, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 4,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(6, tuples.get(0).get("n1"));
assertEquals(7, tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 5,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(1, tuples.size());
assertEquals(7, tuples.get(0).get("n1"));
}
}
// add other records in the context of the transaction
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g',8,6,'n3')", Collections.emptyList(), new TransactionContext(tx));
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g',9,6,'n3')", Collections.emptyList(), new TransactionContext(tx));
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g',10,6,'n3')", Collections.emptyList(), new TransactionContext(tx));
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 ", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(9, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
assertEquals(4, tuples.get(2).get("n1"));
assertEquals(5, tuples.get(3).get("n1"));
assertEquals(6, tuples.get(4).get("n1"));
assertEquals(7, tuples.get(5).get("n1"));
assertEquals(8, tuples.get(6).get("n1"));
assertEquals(9, tuples.get(7).get("n1"));
assertEquals(10, tuples.get(8).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and n2<=7 " + "order by n1 " + "limit 7", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(7, tuples.size());
assertEquals(2, tuples.get(0).get("n1"));
assertEquals(3, tuples.get(1).get("n1"));
assertEquals(4, tuples.get(2).get("n1"));
assertEquals(5, tuples.get(3).get("n1"));
assertEquals(6, tuples.get(4).get("n1"));
assertEquals(7, tuples.get(5).get("n1"));
assertEquals(8, tuples.get(6).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and name='n3' " + "order by n1 " + "limit 200", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(8, tuples.get(0).get("n1"));
assertEquals(9, tuples.get(1).get("n1"));
assertEquals(10, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and name='n3' " + "order by n1 ", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(8, tuples.get(0).get("n1"));
assertEquals(9, tuples.get(1).get("n1"));
assertEquals(10, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and name='n3' " + "order by n1 desc", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertFalse(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(10, tuples.get(0).get("n1"));
assertEquals(9, tuples.get(1).get("n1"));
assertEquals(8, tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>=2 " + "and name='n3' " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(2, tuples.size());
assertEquals(8, tuples.get(0).get("n1"));
assertEquals(9, tuples.get(1).get("n1"));
}
}
}
}
use of herddb.sql.TranslatedQuery in project herddb by diennea.
the class PrimaryIndexScanRangeTest method scanByPKOfIntsWithNegativeValues.
@Test
public void scanByPKOfIntsWithNegativeValues() throws Exception {
Path dataPath = folder.newFolder("data").toPath();
String nodeId = "localhost";
try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new FileDataStorageManager(dataPath), 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);
Table table = Table.builder().tablespace("tblspace1").name("t1").column("n1", ColumnTypes.INTEGER).column("n2", ColumnTypes.INTEGER).column("id", ColumnTypes.STRING).column("name", ColumnTypes.STRING).primaryKey("n1").build();
CreateTableStatement st2 = new CreateTableStatement(table);
manager.executeStatement(st2, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('a',1,5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('b',2,5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('c',-3,6,'n2')", Collections.emptyList());
assertFalse(manager.getTableSpaceManager("tblspace1").getTableManager("t1").isKeyToPageSortedAscending());
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(3, tuples.size());
assertEquals(-3, tuples.get(0).get("n1"));
assertEquals(1, tuples.get(1).get("n1"));
assertEquals(2, tuples.get(2).get("n1"));
}
}
}
}
use of herddb.sql.TranslatedQuery in project herddb by diennea.
the class PrimaryIndexScanRangeTest method primaryIndexPrefixScanWithStringsFileTest.
@Test
public void primaryIndexPrefixScanWithStringsFileTest() throws Exception {
Path dataPath = folder.newFolder("data").toPath();
String nodeId = "localhost";
try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new FileDataStorageManager(dataPath), 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);
Table table = Table.builder().tablespace("tblspace1").name("t1").column("n1", ColumnTypes.STRING).column("n2", ColumnTypes.INTEGER).column("id", ColumnTypes.STRING).column("name", ColumnTypes.STRING).primaryKey("n1").build();
CreateTableStatement st2 = new CreateTableStatement(table);
manager.executeStatement(st2, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('a','1',5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('b','2',5,'n1')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('c','3',6,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('d','5',7,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('e','6',5,'n2')", Collections.emptyList());
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('f','7',7,'n2')", Collections.emptyList());
assertTrue(manager.getTableSpaceManager("tblspace1").getTableManager("t1").isKeyToPageSortedAscending());
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(3, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
assertEquals(RawString.of("6"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertNull(scan.getComparator());
assertNotNull(scan.getLimits());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("3"), tuples.get(0).get("n1"));
assertEquals(RawString.of("6"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 1,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("3"), tuples.get(0).get("n1"));
assertEquals(RawString.of("5"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 3,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("6"), tuples.get(0).get("n1"));
assertEquals(RawString.of("7"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 4,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(1, tuples.size());
assertEquals(RawString.of("7"), tuples.get(0).get("n1"));
}
}
// add a record in the middle of the sorted recordset
DMLStatementExecutionResult res = TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g','4',6,'n2')", Collections.emptyList(), TransactionContext.AUTOTRANSACTION_TRANSACTION);
long tx = res.transactionId;
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(4, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
assertEquals(RawString.of("4"), tuples.get(2).get("n1"));
assertEquals(RawString.of("6"), tuples.get(3).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(6, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
assertEquals(RawString.of("4"), tuples.get(2).get("n1"));
assertEquals(RawString.of("5"), tuples.get(3).get("n1"));
assertEquals(RawString.of("6"), tuples.get(4).get("n1"));
assertEquals(RawString.of("7"), tuples.get(5).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
for (DataAccessor tuple : tuples) {
System.out.println("tuple: " + tuple.toMap());
}
assertEquals(3, tuples.size());
assertEquals(RawString.of("3"), tuples.get(0).get("n1"));
assertEquals(RawString.of("4"), tuples.get(1).get("n1"));
assertEquals(RawString.of("5"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=6 " + "order by n1 " + "limit 1,3", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(3, tuples.size());
assertEquals(RawString.of("3"), tuples.get(0).get("n1"));
assertEquals(RawString.of("4"), tuples.get(1).get("n1"));
assertEquals(RawString.of("6"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 1,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("3"), tuples.get(0).get("n1"));
assertEquals(RawString.of("4"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 3,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("5"), tuples.get(0).get("n1"));
assertEquals(RawString.of("6"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 4,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(2, tuples.size());
assertEquals(RawString.of("6"), tuples.get(0).get("n1"));
assertEquals(RawString.of("7"), tuples.get(1).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 5,2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(1, tuples.size());
assertEquals(RawString.of("7"), tuples.get(0).get("n1"));
}
}
// add other records in the context of the transaction
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g','8',6,'n3')", Collections.emptyList(), new TransactionContext(tx));
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g','9',6,'n3')", Collections.emptyList(), new TransactionContext(tx));
TestUtils.executeUpdate(manager, "INSERT INTO tblspace1.t1(id,n1,n2,name) values('g','A',6,'n3')", Collections.emptyList(), new TransactionContext(tx));
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 ", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(9, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
assertEquals(RawString.of("4"), tuples.get(2).get("n1"));
assertEquals(RawString.of("5"), tuples.get(3).get("n1"));
assertEquals(RawString.of("6"), tuples.get(4).get("n1"));
assertEquals(RawString.of("7"), tuples.get(5).get("n1"));
assertEquals(RawString.of("8"), tuples.get(6).get("n1"));
assertEquals(RawString.of("9"), tuples.get(7).get("n1"));
assertEquals(RawString.of("A"), tuples.get(8).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2 " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and n2<=7 " + "order by n1 " + "limit 7", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
assertEquals(7, tuples.size());
assertEquals(RawString.of("2"), tuples.get(0).get("n1"));
assertEquals(RawString.of("3"), tuples.get(1).get("n1"));
assertEquals(RawString.of("4"), tuples.get(2).get("n1"));
assertEquals(RawString.of("5"), tuples.get(3).get("n1"));
assertEquals(RawString.of("6"), tuples.get(4).get("n1"));
assertEquals(RawString.of("7"), tuples.get(5).get("n1"));
assertEquals(RawString.of("8"), tuples.get(6).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and name='n3' " + "order by n1 " + "limit 200", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(RawString.of("8"), tuples.get(0).get("n1"));
assertEquals(RawString.of("9"), tuples.get(1).get("n1"));
assertEquals(RawString.of("A"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and name='n3' " + "order by n1 ", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(RawString.of("8"), tuples.get(0).get("n1"));
assertEquals(RawString.of("9"), tuples.get(1).get("n1"));
assertEquals(RawString.of("A"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and name='n3' " + "order by n1 desc", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertFalse(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(3, tuples.size());
assertEquals(RawString.of("A"), tuples.get(0).get("n1"));
assertEquals(RawString.of("9"), tuples.get(1).get("n1"));
assertEquals(RawString.of("8"), tuples.get(2).get("n1"));
}
}
{
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT n1,n2,name " + "FROM tblspace1.t1 " + "WHERE n1>='2' " + "and name='n3' " + "order by n1 " + "limit 2", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
assertTrue(scan.getPredicate().getIndexOperation() instanceof PrimaryIndexRangeScan);
assertTrue(scan.getComparator().isOnlyPrimaryKeyAndAscending());
try (DataScanner scan1 = manager.scan(scan, translated.context, new TransactionContext(tx))) {
List<DataAccessor> tuples = scan1.consume();
tuples.forEach(t -> {
System.out.println("OK sortedByClusteredIndex tuple " + t.toMap());
});
assertEquals(2, tuples.size());
assertEquals(RawString.of("8"), tuples.get(0).get("n1"));
assertEquals(RawString.of("9"), tuples.get(1).get("n1"));
}
}
}
}
use of herddb.sql.TranslatedQuery in project herddb by diennea.
the class FileDataStorageManagerRestartTest method recoverTableAndIndexWithoutHash.
@Test
public void recoverTableAndIndexWithoutHash() throws Exception {
Path dataPath = folder.newFolder("data").toPath();
Path logsPath = folder.newFolder("logs").toPath();
Path metadataPath = folder.newFolder("metadata").toPath();
Path tmpDir = folder.newFolder("tmpDir").toPath();
String nodeId = "localhost";
Table table;
Index index;
try (DBManager manager = new DBManager("localhost", new FileMetadataStorageManager(metadataPath), new FileDataStorageManager(dataPath, dataPath.resolve("tmp"), ServerConfiguration.PROPERTY_DISK_SWAP_MAX_RECORDS_DEFAULT, ServerConfiguration.PROPERTY_REQUIRE_FSYNC_DEFAULT, ServerConfiguration.PROPERTY_PAGE_USE_ODIRECT_DEFAULT, ServerConfiguration.PROPERTY_INDEX_USE_ODIRECT_DEFAULT, false, false, new NullStatsLogger()), new FileCommitLogManager(logsPath), tmpDir, 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);
assertTrue(manager.waitForTablespace("tblspace1", 10000));
table = Table.builder().tablespace("tblspace1").name("t1").column("id", ColumnTypes.INTEGER).column("name", ColumnTypes.STRING).primaryKey("id").build();
index = Index.builder().onTable(table).column("name", ColumnTypes.STRING).type(Index.TYPE_BRIN).build();
manager.executeStatement(new CreateTableStatement(table), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
manager.executeStatement(new CreateIndexStatement(index), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
manager.executeStatement(new InsertStatement("tblspace1", table.name, RecordSerializer.makeRecord(table, "id", 1, "name", "uno")), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
GetResult result = manager.get(new GetStatement("tblspace1", table.name, Bytes.from_int(1), null, false), StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
assertTrue(result.found());
/*
* Access through index
*/
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
assertEquals(1, scan1.consume().size());
}
manager.checkpoint();
}
// Enabling hash-chacking: previous stored hashes (value 0) has not to fail the check.
try (DBManager manager = new DBManager("localhost", new FileMetadataStorageManager(metadataPath), new FileDataStorageManager(dataPath, dataPath.resolve("tmp"), ServerConfiguration.PROPERTY_DISK_SWAP_MAX_RECORDS_DEFAULT, ServerConfiguration.PROPERTY_REQUIRE_FSYNC_DEFAULT, ServerConfiguration.PROPERTY_PAGE_USE_ODIRECT_DEFAULT, ServerConfiguration.PROPERTY_INDEX_USE_ODIRECT_DEFAULT, true, true, new NullStatsLogger()), new FileCommitLogManager(logsPath), tmpDir, null)) {
manager.start();
assertTrue(manager.waitForBootOfLocalTablespaces(10000));
/*
* Access through index
*/
TranslatedQuery translated = manager.getPlanner().translate(TableSpace.DEFAULT, "SELECT * FROM tblspace1.t1", Collections.emptyList(), true, true, false, -1);
ScanStatement scan = translated.plan.mainStatement.unwrap(ScanStatement.class);
try (DataScanner scan1 = manager.scan(scan, translated.context, TransactionContext.NO_TRANSACTION)) {
assertEquals(1, scan1.consume().size());
}
}
}
Aggregations