private synchronized void openCursor(Connection conn) throws SQLException { if(isOpen){ return; } this.scan = this.queryPlan.getContext().getScan(); isReversed=OrderBy.REV_ROW_KEY_ORDER_BY.equals(this.queryPlan.getOrderBy()); isOpen = true; }
@Test public void testDegenerateLikeNoWildcard() throws SQLException { String tenantId = "000000000000001"; String keyPrefix = "002"; String query = "select * from atable where organization_id LIKE ? and entity_id LIKE '" + keyPrefix + "'"; List<Object> binds = Arrays.<Object>asList(tenantId); StatementContext context = compileStatement(query, binds); Scan scan = context.getScan(); assertDegenerate(scan); }
private Scan projectQuery(String query) throws SQLException { QueryPlan plan = getQueryPlan(query, Collections.emptyList()); plan.iterator(); // Forces projection return plan.getContext().getScan(); }
@Test public void testDegenerateMult2() throws SQLException { String query = "select * from atable where a_integer * null = 3"; StatementContext context = compileStatement(query); Scan scan = context.getScan(); assertDegenerate(scan); }
@Test public void testDegenerateAdd1() throws SQLException { String query = "select * from atable where a_integer = 3 + null"; StatementContext context = compileStatement(query); Scan scan = context.getScan(); assertDegenerate(scan); }
@Test public void testDegenerateSub1() throws SQLException { String query = "select * from atable where a_integer = 3 - null"; StatementContext context = compileStatement(query); Scan scan = context.getScan(); assertDegenerate(scan); }
@Test public void testMultiCFProjection() throws Exception { Connection conn = DriverManager.getConnection(getUrl()); String ddl = "CREATE TABLE multiCF (k integer primary key, a.a varchar, b.b varchar)"; conn.createStatement().execute(ddl); String query = "SELECT COUNT(*) FROM multiCF"; QueryPlan plan = getQueryPlan(query,Collections.emptyList()); plan.iterator(); Scan scan = plan.getContext().getScan(); assertTrue(scan.getFilter() instanceof FirstKeyOnlyFilter); assertEquals(1, scan.getFamilyMap().size()); }
@Test public void testSelectForceSkipScan() throws Exception { String id = "000000000000001"; // A where clause without the first column usually compiles into a range scan. String query = "SELECT /*+ SKIP_SCAN */ * FROM atable WHERE entity_id='" + id + "'"; Scan scan = compileStatement(query).getContext().getScan(); assertTrue("The first filter should be SkipScanFilter.", usingSkipScan(scan)); }
@Test public void testSelectForceRangeScan() throws Exception { String query = "SELECT /*+ RANGE_SCAN */ * FROM atable WHERE organization_id in (" + "'000000000000001', '000000000000002', '000000000000003', '000000000000004')"; Scan scan = compileStatement(query).getContext().getScan(); // Verify that it is not using SkipScanFilter. assertFalse("The first filter should not be SkipScanFilter.", usingSkipScan(scan)); }
@Test public void testSingleBinaryPaddedKeyExpression() throws SQLException { Connection conn = DriverManager.getConnection(getUrl(), PropertiesUtil.deepCopy(TEST_PROPERTIES)); conn.createStatement().execute("create table bintable (k BINARY(15) PRIMARY KEY)"); String tenantId = "1"; String query = "select * from bintable where k='" + tenantId + "'"; Scan scan = compileStatement(query).getScan(); assertNull(scan.getFilter()); byte[] key = ByteUtil.fillKey(PVarchar.INSTANCE.toBytes(tenantId), 15); assertArrayEquals(key, scan.getStartRow()); assertArrayEquals(ByteUtil.nextKey(key), scan.getStopRow()); }
private static Expressions compileStatement(String query, List<Object> binds) throws SQLException { PhoenixConnection pconn = DriverManager.getConnection(getUrl(), PropertiesUtil.deepCopy(TEST_PROPERTIES)).unwrap(PhoenixConnection.class); PhoenixPreparedStatement pstmt = new PhoenixPreparedStatement(pconn, query); TestUtil.bindParams(pstmt, binds); QueryPlan plan = pstmt.compileQuery(); assertTrue(plan instanceof AggregatePlan); Filter filter = plan.getContext().getScan().getFilter(); assertTrue(filter == null || filter instanceof BooleanExpressionFilter); BooleanExpressionFilter boolFilter = (BooleanExpressionFilter)filter; AggregatePlan aggPlan = (AggregatePlan)plan; return new Expressions(boolFilter == null ? null : boolFilter.getExpression(), aggPlan.getHaving()); }
@Test public void testBoundLimit() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where organization_id='" + tenantId + "' limit ?"; List<Object> binds = Arrays.<Object>asList(5); QueryPlan plan = compileStatement(query, binds); Scan scan = plan.getContext().getScan(); assertNull(scan.getFilter()); assertArrayEquals(PVarchar.INSTANCE.toBytes(tenantId), scan.getStartRow()); assertArrayEquals(ByteUtil.nextKey(PVarchar.INSTANCE.toBytes(tenantId)), scan.getStopRow()); assertEquals(plan.getLimit(),Integer.valueOf(5)); }
@Test public void testCollapseFunctionToNull() throws SQLException { String query = "select * from atable where substr(entity_id,null) = 'foo'"; PhoenixConnection pconn = DriverManager.getConnection(getUrl(), PropertiesUtil.deepCopy(TEST_PROPERTIES)).unwrap(PhoenixConnection.class); PhoenixPreparedStatement pstmt = newPreparedStatement(pconn, query); QueryPlan plan = pstmt.optimizeQuery(); Scan scan = plan.getContext().getScan(); Filter filter = scan.getFilter(); assertNull(filter); assertArrayEquals(scan.getStartRow(),KeyRange.EMPTY_RANGE.getLowerRange()); assertArrayEquals(scan.getStopRow(),KeyRange.EMPTY_RANGE.getUpperRange()); }
@Test public void testSingleKeyNotExpression() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where not organization_id='" + tenantId + "'"; Scan scan = compileStatement(query).getScan(); assertNotNull(scan.getFilter()); assertEquals(0, scan.getStartRow().length); assertEquals(0, scan.getStopRow().length); }
private static void assertQualifierRangesNotPresent(ResultSet rs) throws SQLException { Scan scan = rs.unwrap(PhoenixResultSet.class).getStatement().getQueryPlan().getContext().getScan(); assertNull(scan.getAttribute(MIN_QUALIFIER)); assertNull(scan.getAttribute(MAX_QUALIFIER)); } }
@Test public void testTopLevelOrKeyExpression() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where organization_id='" + tenantId + "' or a_integer=2"; Scan scan = compileStatement(query).getScan(); assertNotNull(scan.getFilter()); assertEquals(0, scan.getStartRow().length); assertEquals(0, scan.getStopRow().length); }
@Test public void testNoLimit() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where organization_id='" + tenantId + "'"; List<Object> binds = Collections.emptyList(); QueryPlan plan = compileStatement(query, binds); Scan scan = plan.getContext().getScan(); assertNull(scan.getFilter()); assertNull(plan.getLimit()); assertArrayEquals(PVarchar.INSTANCE.toBytes(tenantId), scan.getStartRow()); assertArrayEquals(ByteUtil.nextKey(PVarchar.INSTANCE.toBytes(tenantId)), scan.getStopRow()); }
@Test public void testSiblingOrKeyExpression() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where organization_id='" + tenantId + "' and (a_integer = 2 or a_integer = 3)"; Scan scan = compileStatement(query).getScan(); assertNotNull(scan.getFilter()); assertArrayEquals(PVarchar.INSTANCE.toBytes(tenantId), scan.getStartRow()); assertArrayEquals(ByteUtil.nextKey(PVarchar.INSTANCE.toBytes(tenantId)), scan.getStopRow()); }
@Test public void testRHSLiteral() throws SQLException { String tenantId = "000000000000001"; String query = "select * from atable where organization_id='" + tenantId + "' and 0 >= a_integer limit 1000"; StatementContext context = compileStatement(query, 1000); Scan scan = context.getScan(); assertNotNull(scan.getFilter()); assertArrayEquals(PVarchar.INSTANCE.toBytes(tenantId), scan.getStartRow()); assertArrayEquals(ByteUtil.nextKey(PVarchar.INSTANCE.toBytes(tenantId)), scan.getStopRow()); }
private static void assertQualifierRanges(ResultSet rs, int minQualifier, int maxQualifier) throws SQLException { Scan scan = rs.unwrap(PhoenixResultSet.class).getStatement().getQueryPlan().getContext().getScan(); assertNotNull(scan.getAttribute(MIN_QUALIFIER)); assertNotNull(scan.getAttribute(MAX_QUALIFIER)); assertEquals(minQualifier, Bytes.toInt(scan.getAttribute(MIN_QUALIFIER))); assertEquals(maxQualifier, Bytes.toInt(scan.getAttribute(MAX_QUALIFIER))); }