Enhance SHOW DATABASES statement to support LIKE, ILIKE, LIMIT, OUTFILE, and FORMAT clauses (#182)

---------

Co-authored-by: Copilot <[email protected]>
Co-authored-by: git-hulk <[email protected]>

Author: Copilot

parser/ast.go

@@ -8231,13 +8231,34 @@ type ShowStmt struct {
 	StatementEnd Pos
 	ShowType     string           // e.g., "CREATE TABLE", "DATABASES", "TABLES"
 	Target       *TableIdentifier // for SHOW CREATE TABLE table_name
+
+	// Optional clauses for SHOW DATABASES
+	NotLike     bool           // true if NOT LIKE/ILIKE
+	LikeType    string         // "LIKE" or "ILIKE", empty if not used
+	LikePattern Expr           // pattern expression for LIKE/ILIKE
+	Limit       Expr           // limit expression
+	OutFile     *StringLiteral // filename for INTO OUTFILE
+	Format      *StringLiteral // format specification
 }
 
 func (s *ShowStmt) Pos() Pos {
 	return s.ShowPos
 }
 
 func (s *ShowStmt) End() Pos {
+	// Find the rightmost element to determine the end position
+	if s.Format != nil {
+		return s.Format.End()
+	}
+	if s.OutFile != nil {
+		return s.OutFile.End()
+	}
+	if s.Limit != nil {
+		return s.Limit.End()
+	}
+	if s.LikePattern != nil {
+		return s.LikePattern.End()
+	}
 	if s.Target != nil {
 		return s.Target.End()
 	}
@@ -8252,6 +8273,34 @@ func (s *ShowStmt) String() string {
 		builder.WriteString(" ")
 		builder.WriteString(s.Target.String())
 	}
+
+	// Add optional clauses for SHOW DATABASES
+	if s.LikeType != "" && s.LikePattern != nil {
+		if s.NotLike {
+			builder.WriteString(" NOT ")
+		} else {
+			builder.WriteString(" ")
+		}
+		builder.WriteString(s.LikeType)
+		builder.WriteString(" ")
+		builder.WriteString(s.LikePattern.String())
+	}
+
+	if s.Limit != nil {
+		builder.WriteString(" LIMIT ")
+		builder.WriteString(s.Limit.String())
+	}
+
+	if s.OutFile != nil {
+		builder.WriteString(" INTO OUTFILE ")
+		builder.WriteString(s.OutFile.String())
+	}
+
+	if s.Format != nil {
+		builder.WriteString(" FORMAT ")
+		builder.WriteString(s.Format.String())
+	}
+
 	return builder.String()
 }
 
@@ -8263,6 +8312,26 @@ func (s *ShowStmt) Accept(visitor ASTVisitor) error {
 			return err
 		}
 	}
+	if s.LikePattern != nil {
+		if err := s.LikePattern.Accept(visitor); err != nil {
+			return err
+		}
+	}
+	if s.Limit != nil {
+		if err := s.Limit.Accept(visitor); err != nil {
+			return err
+		}
+	}
+	if s.OutFile != nil {
+		if err := s.OutFile.Accept(visitor); err != nil {
+			return err
+		}
+	}
+	if s.Format != nil {
+		if err := s.Format.Accept(visitor); err != nil {
+			return err
+		}
+	}
 	return visitor.VisitShowExpr(s)
 }
 

parser/parser_table.go

@@ -1201,7 +1201,7 @@ func (p *Parser) parseShowStmt(pos Pos) (*ShowStmt, error) {
 		target = tableIdent
 
 	case p.matchKeyword(KeywordDatabases):
-		// SHOW DATABASES
+		// SHOW DATABASES [optional clauses]
 		showType = "DATABASES"
 		_ = p.lexer.consumeToken()
 
@@ -1214,19 +1214,91 @@ func (p *Parser) parseShowStmt(pos Pos) (*ShowStmt, error) {
 		return nil, fmt.Errorf("expected CREATE, DATABASES, or TABLES after SHOW, got %q", p.last().String)
 	}
 
-	var statementEnd Pos
-	if target != nil {
-		statementEnd = target.End()
-	} else {
-		statementEnd = p.End()
+	stmt := &ShowStmt{
+		ShowPos:  pos,
+		ShowType: showType,
+		Target:   target,
 	}
 
-	return &ShowStmt{
-		ShowPos:      pos,
-		StatementEnd: statementEnd,
-		ShowType:     showType,
-		Target:       target,
-	}, nil
+	// Parse optional clauses for SHOW DATABASES
+	if showType == "DATABASES" {
+		// Parse [[NOT] LIKE | ILIKE '<pattern>']
+		if p.matchKeyword(KeywordNot) {
+			stmt.NotLike = true
+			_ = p.lexer.consumeToken()
+		}
+
+		if p.matchKeyword(KeywordLike) || p.matchKeyword(KeywordIlike) {
+			if p.matchKeyword(KeywordLike) {
+				stmt.LikeType = "LIKE"
+			} else {
+				stmt.LikeType = "ILIKE"
+			}
+			_ = p.lexer.consumeToken()
+
+			// Parse pattern expression
+			pattern, err := p.parseExpr(p.Pos())
+			if err != nil {
+				return nil, err
+			}
+			stmt.LikePattern = pattern
+		}
+
+		// Parse [LIMIT <N>]
+		if p.matchKeyword(KeywordLimit) {
+			_ = p.lexer.consumeToken()
+			limit, err := p.parseExpr(p.Pos())
+			if err != nil {
+				return nil, err
+			}
+			stmt.Limit = limit
+		}
+
+		// Parse [INTO OUTFILE filename]
+		if p.matchKeyword(KeywordInto) {
+			_ = p.lexer.consumeToken()
+			if err := p.expectKeyword(KeywordOutfile); err != nil {
+				return nil, err
+			}
+
+			// Parse filename as a string literal
+			outFile, err := p.parseString(p.Pos())
+			if err != nil {
+				return nil, err
+			}
+			stmt.OutFile = outFile
+		}
+
+		// Parse [FORMAT format]
+		if p.matchKeyword(KeywordFormat) {
+			_ = p.lexer.consumeToken()
+
+			// Format can be an identifier or a string
+			if p.matchTokenKind(TokenKindString) {
+				format, err := p.parseString(p.Pos())
+				if err != nil {
+					return nil, err
+				}
+				stmt.Format = format
+			} else if p.matchTokenKind(TokenKindIdent) {
+				// Handle format as identifier (like JSON, CSV, etc.)
+				token := p.last()
+				_ = p.lexer.consumeToken()
+				stmt.Format = &StringLiteral{
+					LiteralPos: token.Pos,
+					LiteralEnd: token.End,
+					Literal:    token.String,
+				}
+			} else {
+				return nil, fmt.Errorf("expected format specification after FORMAT, got %q", p.last().String)
+			}
+		}
+	}
+
+	// Set statement end position
+	stmt.StatementEnd = p.End()
+
+	return stmt, nil
 }
 
 func (p *Parser) parseDescribeStmt(pos Pos) (*DescribeStmt, error) {

parser/testdata/ddl/format/show_databases_comprehensive.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES LIKE 'prod%' LIMIT 5 INTO OUTFILE '/tmp/prod_dbs.txt' FORMAT JSON
+
+-- Format SQL:
+SHOW DATABASES LIKE 'prod%' LIMIT 5 INTO OUTFILE '/tmp/prod_dbs.txt' FORMAT 'JSON';

parser/testdata/ddl/format/show_databases_format.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES FORMAT JSON
+
+-- Format SQL:
+SHOW DATABASES FORMAT 'JSON';

parser/testdata/ddl/format/show_databases_format_string.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES FORMAT 'TabSeparated'
+
+-- Format SQL:
+SHOW DATABASES FORMAT 'TabSeparated';

parser/testdata/ddl/format/show_databases_ilike.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES ILIKE 'Test%'
+
+-- Format SQL:
+SHOW DATABASES ILIKE 'Test%';

parser/testdata/ddl/format/show_databases_like.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES LIKE 'test%'
+
+-- Format SQL:
+SHOW DATABASES LIKE 'test%';

parser/testdata/ddl/format/show_databases_limit.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES LIMIT 10
+
+-- Format SQL:
+SHOW DATABASES LIMIT 10;

parser/testdata/ddl/format/show_databases_not_ilike.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES NOT ILIKE 'Temp%'
+
+-- Format SQL:
+SHOW DATABASES NOT ILIKE 'Temp%';

parser/testdata/ddl/format/show_databases_not_like.sql

@@ -0,0 +1,5 @@
+-- Origin SQL:
+SHOW DATABASES NOT LIKE 'temp%'
+
+-- Format SQL:
+SHOW DATABASES NOT LIKE 'temp%';