[YSQL] #955: Handle primary key as an index

Summary: Primary key of a YSQL table is now handled as a table index so that it can be used in an index scan path. The current ybc_fdw scan path becomes a simple sequential scan.

Test Plan: Jenkins

Reviewers: neil, neha, mihnea

Reviewed By: mihnea

Subscribers: yql

Differential Revision: https://phabricator.dev.yugabyte.com/D6326

java/yb-pgsql/src/test/java/org/yb/pgsql/BasePgSQLTest.java

@@ -579,6 +579,23 @@ protected void assertRowSet(String stmt, Set<Row> expectedRows) throws SQLExcept
     }
   }
 
+  /*
+   * Returns whether or not this select statement uses index.
+   */
+  protected boolean useIndex(String stmt, String index) throws SQLException {
+    try (Statement statement = connection.createStatement()) {
+      try (ResultSet rs = statement.executeQuery("EXPLAIN " + stmt)) {
+        assert(rs.getMetaData().getColumnCount() == 1); // Expecting one string column.
+        while (rs.next()) {
+          if (rs.getString(1).contains("Index Scan using " + index)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }
+  }
+
   /*
    * Returns whether or not this select statement requires filtering by Postgres (i.e. not all
    * conditions can be pushed down to YugaByte).

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgPrepareExecute.java

@@ -106,23 +106,24 @@ public void testJdbcPrepareExecute() throws Exception {
     }
 
     // Test bind variable pushdown:
-    // Equality on hash key -- expect no postgres filtering, everything should be pushed to YB.
+    // Equality on hash key -- expect index is used with index condition.
     String query = "EXPLAIN SELECT * FROM test WHERE h = ?";
     try (PreparedStatement sel = connection.prepareStatement(query)) {
       sel.setLong(1, 2);
       ResultSet rs = sel.executeQuery();
       List<Row> rows = getRowList(rs);
-      assertFalse(rows.toString().contains("Filter: "));
+      assertTrue(rows.toString().contains("Index Cond: "));
     }
 
     // Test bind variable pushdown:
-    // Inequality on hash key -- expect postgres filtering.
+    // Inequality on hash key -- expect index is used also with index condition. We do not support
+    // hash inequality in DocDB yet and the filtering is done inside the YB's index access method.
     query = "EXPLAIN SELECT * FROM test WHERE h > ?";
     try (PreparedStatement sel = connection.prepareStatement(query)) {
       sel.setLong(1, 2);
       ResultSet rs = sel.executeQuery();
       List<Row> rows = getRowList(rs);
-      assertTrue(rows.toString().contains("Filter: "));
+      assertTrue(rows.toString().contains("Index Cond: "));
     }
   }
 

java/yb-pgsql/src/test/java/org/yb/pgsql/TestPgSelect.java

@@ -35,13 +35,14 @@ public class TestPgSelect extends BasePgSQLTest {
   @Test
   public void testWhereClause() throws Exception {
     List<Row> allRows = setupSimpleTable("test_where");
+    final String PRIMARY_KEY = "test_where_pkey";
     try (Statement statement = connection.createStatement()) {
       // Test no where clause -- select all rows.
       String query = "SELECT * FROM test_where";
       try (ResultSet rs = statement.executeQuery(query)) {
         assertEquals(allRows, getSortedRowList(rs));
       }
-      assertFalse(needsPgFiltering(query));
+      assertFalse(useIndex(query, PRIMARY_KEY));
 
       // Test fixed hash key.
       query = "SELECT * FROM test_where WHERE h = 2";
@@ -52,7 +53,7 @@ public void testWhereClause() throws Exception {
         assertEquals(10, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertFalse(needsPgFiltering(query));
+      assertTrue(useIndex(query, PRIMARY_KEY));
 
       // Test fixed primary key.
       query = "SELECT * FROM test_where WHERE h = 2 AND r = 3.5";
@@ -64,7 +65,7 @@ public void testWhereClause() throws Exception {
         assertEquals(1, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertFalse(needsPgFiltering(query));
+      assertTrue(useIndex(query, PRIMARY_KEY));
 
       // Test fixed range key without fixed hash key.
       query = "SELECT * FROM test_where WHERE r = 6.5";
@@ -75,7 +76,7 @@ public void testWhereClause() throws Exception {
         assertEquals(10, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertTrue(needsPgFiltering(query));
+      assertTrue(useIndex(query, PRIMARY_KEY));
 
       // Test range scan.
       query = "SELECT * FROM test_where WHERE h = 2 AND r >= 3.5 AND r < 8.5";
@@ -88,7 +89,7 @@ public void testWhereClause() throws Exception {
         assertEquals(5, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertTrue(needsPgFiltering(query));
+      assertTrue(useIndex(query, PRIMARY_KEY));
 
       // Test conditions on regular (non-primary-key) columns.
       query = "SELECT * FROM test_where WHERE vi < 14 AND vs != 'v09'";
@@ -101,10 +102,10 @@ public void testWhereClause() throws Exception {
         assertEquals(13, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertTrue(needsPgFiltering(query));
+      assertFalse(useIndex(query, PRIMARY_KEY));
 
       // Test other WHERE operators (IN, OR, LIKE).
-      query = "SELECT * FROM test_where WHERE h IN (2,3) OR vs LIKE 'v_2'";
+      query = "SELECT * FROM test_where WHERE h = 2 OR h = 3 OR vs LIKE 'v_2'";
       try (ResultSet rs = statement.executeQuery(query)) {
         List<Row> expectedRows = allRows.stream()
             .filter(row -> row.getLong(0).equals(2L) ||
@@ -115,7 +116,7 @@ public void testWhereClause() throws Exception {
         assertEquals(28, expectedRows.size());
         assertEquals(expectedRows, getSortedRowList(rs));
       }
-      assertTrue(needsPgFiltering(query));
+      assertFalse(useIndex(query, PRIMARY_KEY));
     }
   }
 
@@ -228,7 +229,7 @@ public void testJoins() throws Exception {
 
       // Test join with WHERE clause.
       joinStmt = "SELECT a.h, a.r, a.v as av, b.v as bv FROM t1 a LEFT JOIN t2 b " +
-          "ON (a.h = b.h and a.r = b.r) WHERE a.h = 1 AND a.r IN (2.5, 3.5)";
+          "ON (a.h = b.h and a.r = b.r) WHERE a.h = 1 AND (a.r = 2.5 OR a.r = 3.5)";
       try (ResultSet rs = statement.executeQuery(joinStmt)) {
         assertNextRow(rs, 1L, 2.5D, "abc", "foo");
         assertNextRow(rs, 1L, 3.5D, "def", null);

src/postgres/src/backend/access/index/indexam.c

@@ -633,9 +633,19 @@ index_getnext_tid(IndexScanDesc scan, ScanDirection direction)
 HeapTuple
 index_fetch_heap(IndexScanDesc scan)
 {
-	/* For YugaByte index, we need to select from the base table using ybctid */
+	/*
+	 * For YugaByte secondary indexes, we need to select from the base table using
+	 * ybctid. For primary keys, the row is already prepared in "xs_hitup" that can
+	 * be returned directly.
+	 */
 	if (IsYugaByteEnabled())
 	{
+		if (scan->indexRelation->rd_index->indisprimary)
+		{
+			Assert(scan->xs_hitup != 0);
+			return scan->xs_hitup;
+		}
+
 		return YBCFetchTuple(scan->heapRelation, scan->xs_ctup.t_ybctid);
 	}