pgsql wire

cmd/immudb/command/immudbcmdtest/immuServerMock.go

@@ -29,11 +29,11 @@ type ImmuServerMock struct {
 	Logger      logger.Logger
 	StateSigner server.StateSigner
 	Ssf         stream.ServiceFactory
-	PgsqlSrv    pgsqlsrv.Server
+	PgsqlSrv    pgsqlsrv.PGSQLServer
 	DbList      database.DatabaseList
 }
 
-func (s *ImmuServerMock) WithPgsqlServer(psrv pgsqlsrv.Server) server.ImmuServerIf {
+func (s *ImmuServerMock) WithPgsqlServer(psrv pgsqlsrv.PGSQLServer) server.ImmuServerIf {
 	s.PgsqlSrv = psrv
 	return s
 }

embedded/sql/catalog.go

@@ -79,11 +79,56 @@ type Column struct {
 }
 
 func newCatalog(enginePrefix []byte) *Catalog {
-	return &Catalog{
+	ctlg := &Catalog{
 		enginePrefix: enginePrefix,
 		tablesByID:   make(map[uint32]*Table),
 		tablesByName: make(map[string]*Table),
 	}
+
+	pgTypeTable := &Table{
+		catalog: ctlg,
+		name:    "pg_type",
+		cols: []*Column{
+			{
+				colName: "oid",
+				colType: VarcharType,
+				maxLen:  10,
+			},
+			{
+				colName: "typbasetype",
+				colType: VarcharType,
+				maxLen:  10,
+			},
+			{
+				colName: "typname",
+				colType: VarcharType,
+				maxLen:  50,
+			},
+		},
+	}
+
+	pgTypeTable.colsByName = make(map[string]*Column, len(pgTypeTable.cols))
+
+	for _, col := range pgTypeTable.cols {
+		pgTypeTable.colsByName[col.colName] = col
+	}
+
+	pgTypeTable.indexes = []*Index{
+		{
+			unique: true,
+			cols: []*Column{
+				pgTypeTable.colsByName["oid"],
+			},
+			colsByID: map[uint32]*Column{
+				0: pgTypeTable.colsByName["oid"],
+			},
+		},
+	}
+
+	pgTypeTable.primaryIndex = pgTypeTable.indexes[0]
+	ctlg.tablesByName[pgTypeTable.name] = pgTypeTable
+
+	return ctlg
 }
 
 func (catlg *Catalog) ExistTable(table string) bool {

embedded/sql/engine_test.go

@@ -96,6 +96,13 @@ func TestUseDatabaseWithoutMultiDBHandler(t *testing.T) {
 		_, err := engine.Query(context.Background(), nil, "SELECT * FROM DATABASES()", nil)
 		require.ErrorIs(t, err, ErrUnspecifiedMultiDBHandler)
 	})
+
+	r, err := engine.Query(context.Background(), nil, "SELECT ts FROM pg_type WHERE ts < 1 + NOW()", nil)
+	require.NoError(t, err)
+	defer r.Close()
+
+	_, err = r.Read(context.Background())
+	require.ErrorIs(t, err, ErrNoMoreRows)
 }
 
 func TestCreateTable(t *testing.T) {
@@ -6017,6 +6024,25 @@ func TestMultiDBCatalogQueries(t *testing.T) {
 			require.NoError(t, err)
 		})
 
+		t.Run("show databases", func(t *testing.T) {
+			r, err := engine.Query(context.Background(), nil, "SHOW DATABASES", nil)
+			require.NoError(t, err)
+
+			for _, db := range dbs {
+				row, err := r.Read(context.Background())
+				require.NoError(t, err)
+				require.NotNil(t, row)
+				require.NotNil(t, row)
+				require.Equal(t, db, row.ValuesBySelector["(databases.name)"].RawValue())
+			}
+
+			_, err = r.Read(context.Background())
+			require.ErrorIs(t, err, ErrNoMoreRows)
+
+			err = r.Close()
+			require.NoError(t, err)
+		})
+
 		t.Run("query databases using conditions with table and column aliasing", func(t *testing.T) {
 			r, err := engine.Query(context.Background(), nil, "SELECT dbs.name as dbname FROM DATABASES() as dbs WHERE name LIKE 'db*'", nil)
 			require.NoError(t, err)
@@ -6136,6 +6162,24 @@ func TestSingleDBCatalogQueries(t *testing.T) {
 		require.ErrorIs(t, err, ErrNoMoreRows)
 	})
 
+	t.Run("show tables", func(t *testing.T) {
+		r, err := engine.Query(context.Background(), tx, "SHOW TABLES", nil)
+		require.NoError(t, err)
+
+		defer r.Close()
+
+		row, err := r.Read(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, "mytable1", row.ValuesBySelector["(tables.name)"].RawValue())
+
+		row, err = r.Read(context.Background())
+		require.NoError(t, err)
+		require.Equal(t, "mytable2", row.ValuesBySelector["(tables.name)"].RawValue())
+
+		_, err = r.Read(context.Background())
+		require.ErrorIs(t, err, ErrNoMoreRows)
+	})
+
 	t.Run("unconditional index query should return all the indexes of mytable1", func(t *testing.T) {
 		params := map[string]interface{}{
 			"tableName": "mytable1",

embedded/sql/parser.go

@@ -92,6 +92,9 @@ var reservedWords = map[string]int{
 	"IS":             IS,
 	"CAST":           CAST,
 	"::":             SCAST,
+	"SHOW":           SHOW,
+	"DATABASES":      DATABASES,
+	"TABLES":         TABLES,
 }
 
 var joinTypes = map[string]JoinType{

embedded/sql/row_reader.go

@@ -145,6 +145,25 @@ func (d *ColDescriptor) Selector() string {
 	return EncodeSelector(d.AggFn, d.Table, d.Column)
 }
 
+type emptyKeyReader struct {
+}
+
+func (r emptyKeyReader) Read(ctx context.Context) (key []byte, val store.ValueRef, err error) {
+	return nil, nil, store.ErrNoMoreEntries
+}
+
+func (r emptyKeyReader) ReadBetween(ctx context.Context, initialTxID uint64, finalTxID uint64) (key []byte, val store.ValueRef, err error) {
+	return nil, nil, store.ErrNoMoreEntries
+}
+
+func (r emptyKeyReader) Reset() error {
+	return nil
+}
+
+func (r emptyKeyReader) Close() error {
+	return nil
+}
+
 func newRawRowReader(tx *SQLTx, params map[string]interface{}, table *Table, period period, tableAlias string, scanSpecs *ScanSpecs) (*rawRowReader, error) {
 	if table == nil || scanSpecs == nil || scanSpecs.Index == nil {
 		return nil, ErrIllegalArguments
@@ -155,9 +174,15 @@ func newRawRowReader(tx *SQLTx, params map[string]interface{}, table *Table, per
 		return nil, err
 	}
 
-	r, err := tx.newKeyReader(*rSpec)
-	if err != nil {
-		return nil, err
+	var r store.KeyReader
+
+	if table.name == "pg_type" {
+		r = &emptyKeyReader{}
+	} else {
+		r, err = tx.newKeyReader(*rSpec)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if tableAlias == "" {

embedded/sql/sql_grammar.y

@@ -75,6 +75,7 @@ func setResult(l yyLexer, stmts []SQLStmt) {
 %token SELECT DISTINCT FROM JOIN HAVING WHERE GROUP BY LIMIT OFFSET ORDER ASC DESC AS UNION ALL
 %token NOT LIKE IF EXISTS IN IS
 %token AUTO_INCREMENT NULL CAST SCAST
+%token SHOW DATABASES TABLES
 %token <id> NPARAM
 %token <pparam> PPARAM
 %token <joinType> JOINTYPE
@@ -523,6 +524,20 @@ dqlstmt:
             right: $4.(DataSource),
         }
     }
+|
+    SHOW DATABASES
+    {
+        $$ = &SelectStmt{
+            ds: &FnDataSourceStmt{fnCall: &FnCall{fn: "databases"}},
+        }
+    }
+|
+    SHOW TABLES
+    {
+        $$ = &SelectStmt{
+            ds: &FnDataSourceStmt{fnCall: &FnCall{fn: "tables"}},
+        }
+    }
 
 select_stmt: SELECT opt_distinct opt_selectors FROM ds opt_indexon opt_joins opt_where opt_groupby opt_having opt_orderby opt_limit opt_offset
     {
@@ -625,6 +640,16 @@ ds:
         $2.(*SelectStmt).as = $4
         $$ = $2.(DataSource)
     }
+|
+    DATABASES '(' ')' opt_as
+    {
+        $$ = &FnDataSourceStmt{fnCall: &FnCall{fn: "databases"}, as: $4}
+    }
+|
+    TABLES '(' ')' opt_as
+    {
+        $$ = &FnDataSourceStmt{fnCall:  &FnCall{fn: "tables"}, as: $4}
+    }
 |
     fnCall opt_as
     {