From f9faf0ada3d873c3fe64ea6298cd5111b43d55f7 Mon Sep 17 00:00:00 2001 From: Alexandr Gorshenin Date: Fri, 30 Aug 2024 13:27:40 +0100 Subject: [PATCH] Updated tests for full scan detector --- .../ydb/jdbc/impl/YdbConnectionImplTest.java | 231 ++++++++++++++---- .../jdbc/impl/YdbQueryConnectionImplTest.java | 231 ++++++++++++++---- .../tech/ydb/jdbc/impl/helper/SqlQueries.java | 15 +- .../ydb/jdbc/impl/helper/StatsAssert.java | 55 +++++ .../ydb/jdbc/impl/helper/TableAssert.java | 30 +++ 5 files changed, 463 insertions(+), 99 deletions(-) create mode 100644 jdbc/src/test/java/tech/ydb/jdbc/impl/helper/StatsAssert.java diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbConnectionImplTest.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbConnectionImplTest.java index 578da30..1438bd7 100644 --- a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbConnectionImplTest.java +++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbConnectionImplTest.java @@ -28,6 +28,7 @@ import tech.ydb.jdbc.impl.helper.ExceptionAssert; import tech.ydb.jdbc.impl.helper.JdbcConnectionExtention; import tech.ydb.jdbc.impl.helper.SqlQueries; +import tech.ydb.jdbc.impl.helper.StatsAssert; import tech.ydb.jdbc.impl.helper.TableAssert; import tech.ydb.test.junit5.YdbHelperExtension; @@ -927,83 +928,215 @@ public void testUnsupportedComplexTypes(String type) throws SQLException { } @Test - public void testFullScanAnalyzer() throws SQLException { - try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { - String selectAll = QUERIES.selectAllSQL(); - String selectByKey = QUERIES.selectAllByKey("1"); - String preparedSelect = QUERIES.selectAllByKey("?"); + public void fullScanAnalyzerSchemeQueriesTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String createTable = QUERIES.withTableName("CREATE TABLE #tableName_1(id Int32, value Int32, PRIMARY KEY(id))"); + String dropTable = QUERIES.withTableName("DROP TABLE #tableName_1;"); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { try (Statement st = connection.createStatement()) { try (ResultSet rs = st.executeQuery(" print_JDBC_stats(); ")) { - Assertions.assertFalse(rs.next()); // not stats + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); } - try (ResultSet rs = st.executeQuery(selectAll)) { - Assertions.assertFalse(rs.next()); + // scheme queries don't collect stats + Assertions.assertFalse(st.execute(createTable)); + Assertions.assertFalse(st.execute(dropTable)); + + try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + } + } + } + + @Test + public void fullScanAnalyzerSchemeWrongQueryTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String wrongQuery = QUERIES.withTableName("select * from wrong_table;"); + + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); } + // scheme queries don't collect stats + ExceptionAssert.ydbException("Cannot find table", () -> st.execute(wrongQuery)); + try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); - Assertions.assertFalse(rs.next()); + check.nextRow( + sa.sql("select * from wrong_table;"), + sa.yql("select * from wrong_table;"), + sa.isNotFullScan(), sa.isError(), sa.executed(1), sa.hasNoAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } + } + } + } + + @Test + public void fullScanAnalyzerStatementTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String selectAll = QUERIES.selectAllSQL(); + String selectByKey = QUERIES.selectAllByKey("1"); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery(" print_JDBC_stats(); ")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + + // full scan query try (ResultSet rs = st.executeQuery(selectAll)) { Assertions.assertFalse(rs.next()); } + + try (ResultSet rs = st.executeQuery("\tPrint_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + + // key read query try (ResultSet rs = st.executeQuery(selectByKey)) { Assertions.assertFalse(rs.next()); } - try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(2l, rs.getLong("executed")); + try (ResultSet rs = st.executeQuery("print_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectByKey, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + check.nextRow( + sa.sql("select * from ydb_connection_test where key = 1"), + sa.yql("select * from ydb_connection_test where key = 1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + + // key read query + try (ResultSet rs = st.executeQuery(selectByKey)) { Assertions.assertFalse(rs.next()); } - try (PreparedStatement ps = connection.prepareStatement(preparedSelect)) { - ps.setLong(1, 1); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } - ps.setLong(1, 2); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } - ps.setLong(1, 3); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } + try (ResultSet rs = st.executeQuery("print_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = 1"), + sa.yql("select * from ydb_connection_test where key = 1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } + } + } + } - try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(preparedSelect, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(3l, rs.getLong("executed")); + @Test + public void fullScanAnalyzerPreparedStatementTest() throws SQLException { + StatsAssert sa = new StatsAssert(); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(2l, rs.getLong("executed")); + String preparedSelectByKey = QUERIES.selectAllByKey("?"); + String preparedSelectByColumn = QUERIES.selectAllByColumnValue("c_Text", "?"); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectByKey, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + } - Assertions.assertFalse(rs.next()); + try (PreparedStatement ps = connection.prepareStatement(preparedSelectByKey)) { + ps.setInt(1, 1); + ps.execute(); + + ps.setInt(1, 2); + ps.execute(); + } + + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = ?"), + sa.yql("DECLARE $jp1 AS Int32;\nselect * from ydb_connection_test where key = $jp1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + } + + try (PreparedStatement ps = connection.prepareStatement(preparedSelectByColumn)) { + ps.setString(1, "v1"); + ps.execute(); + + ps.setString(1, null); + ps.execute(); + } + + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = ?"), + sa.yql("DECLARE $jp1 AS Int32;\nselect * from ydb_connection_test where key = $jp1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where c_Text = ?"), + sa.yql("DECLARE $jp1 AS Text;\nselect * from ydb_connection_test where c_Text = $jp1"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where c_Text = ?"), + sa.yql("DECLARE $jp1 AS Text?;\nselect * from ydb_connection_test where c_Text = $jp1"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } } } diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbQueryConnectionImplTest.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbQueryConnectionImplTest.java index 13a0cc8..4d9059e 100644 --- a/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbQueryConnectionImplTest.java +++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/YdbQueryConnectionImplTest.java @@ -29,6 +29,7 @@ import tech.ydb.jdbc.impl.helper.ExceptionAssert; import tech.ydb.jdbc.impl.helper.JdbcConnectionExtention; import tech.ydb.jdbc.impl.helper.SqlQueries; +import tech.ydb.jdbc.impl.helper.StatsAssert; import tech.ydb.jdbc.impl.helper.TableAssert; import tech.ydb.test.junit5.YdbHelperExtension; @@ -930,83 +931,215 @@ public void testUnsupportedComplexTypes(String type) throws SQLException { } @Test - public void testFullScanAnalyzer() throws SQLException { - try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { - String selectAll = QUERIES.selectAllSQL(); - String selectByKey = QUERIES.selectAllByKey("1"); - String preparedSelect = QUERIES.selectAllByKey("?"); + public void fullScanAnalyzerSchemeQueriesTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String createTable = QUERIES.withTableName("CREATE TABLE #tableName_1(id Int32, value Int32, PRIMARY KEY(id))"); + String dropTable = QUERIES.withTableName("DROP TABLE #tableName_1;"); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { try (Statement st = connection.createStatement()) { try (ResultSet rs = st.executeQuery(" print_JDBC_stats(); ")) { - Assertions.assertFalse(rs.next()); // not stats + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); } - try (ResultSet rs = st.executeQuery(selectAll)) { - Assertions.assertFalse(rs.next()); + // scheme queries don't collect stats + Assertions.assertFalse(st.execute(createTable)); + Assertions.assertFalse(st.execute(dropTable)); + + try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + } + } + } + + @Test + public void fullScanAnalyzerSchemeWrongQueryTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String wrongQuery = QUERIES.withTableName("select * from wrong_table;"); + + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); } + // scheme queries don't collect stats + ExceptionAssert.ydbException("Cannot find table", () -> st.execute(wrongQuery)); + try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); - Assertions.assertFalse(rs.next()); + check.nextRow( + sa.sql("select * from wrong_table;"), + sa.yql("select * from wrong_table;"), + sa.isNotFullScan(), sa.isError(), sa.executed(1), sa.hasNoAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } + } + } + } + + @Test + public void fullScanAnalyzerStatementTest() throws SQLException { + StatsAssert sa = new StatsAssert(); + + String selectAll = QUERIES.selectAllSQL(); + String selectByKey = QUERIES.selectAllByKey("1"); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery(" print_JDBC_stats(); ")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + + // full scan query try (ResultSet rs = st.executeQuery(selectAll)) { Assertions.assertFalse(rs.next()); } + + try (ResultSet rs = st.executeQuery("\tPrint_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + + // key read query try (ResultSet rs = st.executeQuery(selectByKey)) { Assertions.assertFalse(rs.next()); } - try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(2l, rs.getLong("executed")); + try (ResultSet rs = st.executeQuery("print_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectByKey, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + check.nextRow( + sa.sql("select * from ydb_connection_test where key = 1"), + sa.yql("select * from ydb_connection_test where key = 1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + + // key read query + try (ResultSet rs = st.executeQuery(selectByKey)) { Assertions.assertFalse(rs.next()); } - try (PreparedStatement ps = connection.prepareStatement(preparedSelect)) { - ps.setLong(1, 1); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } - ps.setLong(1, 2); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } - ps.setLong(1, 3); - try (ResultSet rs = ps.executeQuery()) { - Assertions.assertFalse(rs.next()); - } + try (ResultSet rs = st.executeQuery("print_JDBC_staTs();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = 1"), + sa.yql("select * from ydb_connection_test where key = 1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test"), + sa.yql("select * from ydb_connection_test"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } + } + } + } - try (ResultSet rs = st.executeQuery("Print_JDBC_stats();\n")) { - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(preparedSelect, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(3l, rs.getLong("executed")); + @Test + public void fullScanAnalyzerPreparedStatementTest() throws SQLException { + StatsAssert sa = new StatsAssert(); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectAll, rs.getString("sql")); - Assertions.assertEquals(true, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(2l, rs.getLong("executed")); + String preparedSelectByKey = QUERIES.selectAllByKey("?"); + String preparedSelectByColumn = QUERIES.selectAllByColumnValue("c_Text", "?"); - Assertions.assertTrue(rs.next()); - Assertions.assertEquals(selectByKey, rs.getString("sql")); - Assertions.assertEquals(false, rs.getBoolean("is_fullscan")); - Assertions.assertEquals(1l, rs.getLong("executed")); + try (Connection connection = jdbc.createCustomConnection("jdbcFullScanDetector", "true")) { + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + sa.check(rs) + .assertMetaColumns() + .assertNoRows(); + } + } - Assertions.assertFalse(rs.next()); + try (PreparedStatement ps = connection.prepareStatement(preparedSelectByKey)) { + ps.setInt(1, 1); + ps.execute(); + + ps.setInt(1, 2); + ps.execute(); + } + + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = ?"), + sa.yql("DECLARE $jp1 AS Int32;\nselect * from ydb_connection_test where key = $jp1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); + } + } + + try (PreparedStatement ps = connection.prepareStatement(preparedSelectByColumn)) { + ps.setString(1, "v1"); + ps.execute(); + + ps.setString(1, null); + ps.execute(); + } + + try (Statement st = connection.createStatement()) { + try (ResultSet rs = st.executeQuery("print_JDBC_stats();")) { + TableAssert.ResultSetAssert check = sa.check(rs).assertMetaColumns(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where key = ?"), + sa.yql("DECLARE $jp1 AS Int32;\nselect * from ydb_connection_test where key = $jp1"), + sa.isNotFullScan(), sa.isNotError(), sa.executed(2), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where c_Text = ?"), + sa.yql("DECLARE $jp1 AS Text;\nselect * from ydb_connection_test where c_Text = $jp1"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.nextRow( + sa.sql("select * from ydb_connection_test where c_Text = ?"), + sa.yql("DECLARE $jp1 AS Text?;\nselect * from ydb_connection_test where c_Text = $jp1"), + sa.isFullScan(), sa.isNotError(), sa.executed(1), sa.hasAst(), sa.hasPlan() + ).assertAll(); + + check.assertNoRows(); } } } diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/SqlQueries.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/SqlQueries.java index f5c718d..cf68236 100644 --- a/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/SqlQueries.java +++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/SqlQueries.java @@ -39,6 +39,7 @@ public enum YqlQuery { private static final String SELECT_ALL = "select * from #tableName"; private static final String SELECT_BY_KEY = "select * from #tableName where key = #value"; + private static final String SELECT_BY_COLUMN = "select * from #tableName where #column = #value"; private static final String DELETE_ALL = "delete from #tableName"; private static final String SELECT_COLUMN = "select key, #column from #tableName"; private static final String WRONG_SELECT = "select key2 from #tableName"; @@ -98,11 +99,23 @@ public String selectAllSQL() { return withTableName(SELECT_ALL); } - /** @return select * from #tableName where key = #value */ + /** + * @param value key value + * @return select * from #tableName where key = #value + */ public String selectAllByKey(String value) { return withTableName(SELECT_BY_KEY).replaceAll("#value", value); } + /** + * @param column column name + * @param value column value + * @return select * from #tableName where #column = #value + */ + public String selectAllByColumnValue(String column, String value) { + return withTableName(SELECT_BY_COLUMN).replaceAll("#column", column).replaceAll("#value", value); + } + /** @return select key, c_Bool, c_Int8, ... , from #tableName */ public String selectSQL() { return withTableName(SELECT); diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/StatsAssert.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/StatsAssert.java new file mode 100644 index 0000000..ecc2a2a --- /dev/null +++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/StatsAssert.java @@ -0,0 +1,55 @@ +package tech.ydb.jdbc.impl.helper; + +/** + * + * @author Aleksandr Gorshenin + */ +public final class StatsAssert extends TableAssert { + private final TextColumn querySql = addTextColumn("sql", "Text");; + private final BoolColumn isFullScan = addBoolColumn("is_fullscan", "Bool");; + private final BoolColumn isError = addBoolColumn("is_error", "Bool"); + private final LongColumn executed = addLongColumn("executed", "Int64"); + private final TextColumn queryYql= addTextColumn("yql", "Text"); + private final TextColumn queryAst = addTextColumn("ast", "Text"); + private final TextColumn queryPlan = addTextColumn("plan", "Text"); + + public ValueAssert sql(String sql) { + return querySql.eq(sql); + } + + public ValueAssert yql(String yql) { + return queryYql.eq(yql); + } + + public ValueAssert hasAst() { + return queryAst.isNotEmpty(); + } + + public ValueAssert hasNoAst() { + return queryAst.isNull(); + } + + public ValueAssert hasPlan() { + return queryPlan.isNotEmpty(); + } + + public ValueAssert executed(long count) { + return executed.eq(count); + } + + public ValueAssert isFullScan() { + return isFullScan.eq(true); + } + + public ValueAssert isNotFullScan() { + return isFullScan.eq(false); + } + + public ValueAssert isError() { + return isError.eq(true); + } + + public ValueAssert isNotError() { + return isError.eq(false); + } +} diff --git a/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/TableAssert.java b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/TableAssert.java index d0a6a66..e9449d9 100644 --- a/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/TableAssert.java +++ b/jdbc/src/test/java/tech/ydb/jdbc/impl/helper/TableAssert.java @@ -233,6 +233,36 @@ public void assertValue(ResultSet rs) throws SQLException { } }; } + + public ValueAssert isNull() { + return new ValueAssert(this) { + @Override + public void assertValue(ResultSet rs) throws SQLException { + Assertions.assertNull(rs.getString(column.name), + "Not null text value for column label " + column.name); + Assertions.assertTrue(rs.wasNull(), "Not null value for column label " + column.name); + + Assertions.assertNull(rs.getString(column.index), + "Not null value for column index " + column.index); + Assertions.assertTrue(rs.wasNull(), "Not null text value of column index " + column.index); + } + }; + } + + public ValueAssert isNotEmpty() { + return new ValueAssert(this) { + @Override + public void assertValue(ResultSet rs) throws SQLException { + String v1 = rs.getString(column.name); + Assertions.assertFalse(rs.wasNull(), "Null value for column label " + column.name); + Assertions.assertFalse(v1.isEmpty(), "Empty text value for column label " + column.name); + + String v2 = rs.getString(column.index); + Assertions.assertFalse(rs.wasNull(), "Null value for column index " + column.index); + Assertions.assertFalse(v2.isEmpty(), "Empty text value of column index " + column.index); + } + }; + } } public class IntColumn extends Column {