fix edge cases for DO, VACUUM, REVOKE, permissions/roles and multi role parsing

Author: richarah

README.md

@@ -113,6 +113,27 @@ stmt = (sqlglot.select(["id", "name"])
 diff = sqlglot.diff("SELECT id FROM users", "SELECT user_id FROM users")
 ```
 
+### Unix Pipes
+
+libsqlglot can be used in Unix pipelines via the Python CLI:
+
+```bash
+# Basic transpilation
+echo "SELECT \`id\` FROM \`users\`" | python3 -m libsqlglot -r mysql -w postgres
+# Output: SELECT "id" FROM "users"
+
+# Pipeline with grep
+cat queries.sql | python3 -m libsqlglot -r mysql -w bigquery | grep "SELECT"
+
+# Process multiple files
+cat *.sql | python3 -m libsqlglot -r sqlserver -w postgres > output.sql
+
+# Combine with other tools
+find . -name "*.sql" -exec cat {} \; | python3 -m libsqlglot -r mysql -w postgres | wc -l
+```
+
+The CLI reads SQL from stdin and writes transpiled SQL to stdout, making it composable with standard Unix tools.
+
 See [Supported SQL dialects](#supported-sql-dialects) for all available dialect names.
 
 **Python API**: `parse()`, `parse_one()`, `generate()`, `transpile()`, `optimize()`, `diff()`, `.sql()`, `.find_all()`, `.walk()`, `select()` builder.
@@ -218,7 +239,7 @@ cmake --build build
 
 ## Architecture
 
-Header-only design: you only pay for what you use. 19 header files, no `.cpp`. See `include/libsqlglot/` for the full layout. Core files: `parser.h` (4016 lines), `generator.h` (2092), `expression.h` (1376, 115 expression types). Entry point is `transpiler.h` (86 lines).
+Header-only design: you only pay for what you use. 19 header files, no `.cpp`. See `include/libsqlglot/` for the full layout. Core files: `parser.h` (4157 lines), `generator.h` (2137), `expression.h` (1385, 115 expression types). Entry point is `transpiler.h` (86 lines).
 
 ### Memory management
 
@@ -591,9 +612,9 @@ These dialects inherit features from a compatible base dialect and add specific
 
 # Contributing
 
-libsqlglot is a solo project. Bug reports, test cases, and dialect edge cases are welcome via GitHub issues.
+libsqlglot is a solo project. Bug reports, test cases, and dialect edge cases are welcome via GitHub issues. If you have a dialect you wish to see added, please open an issue or PR.
 
-If you find a query that parses incorrectly, or a dialect transformation that produces wrong output, please open an issue with the input SQL, source dialect, target dialect, and expected output.
+If a query parses incorrectly, or a dialect transformation that produces wrong output, please open an issue with the input SQL, source dialect, target dialect, expected output and any other pertinent details.
 
 Pull requests are considered but there is no guarantee of merge. The codebase is intentionally small and opinionated.
 

include/libsqlglot/expression.h

@@ -1121,24 +1121,33 @@ struct CreateIndexAdvStmt : Expression {
 /// DO block (PostgreSQL anonymous code block)
 struct DoBlockStmt : Expression {
     std::string language;                         // plpgsql, sql, etc.
-    std::vector<Expression*> statements;          // Block body
+    bool language_explicit = false;               // Was LANGUAGE explicitly specified?
+    std::vector<Expression*> statements;          // Block body (parsed statements)
+    std::string raw_body;                         // Raw body text (for dollar-quoted strings)
+    std::string delimiter;                        // Dollar quote delimiter (e.g., "$$", "$custom$")
 
     DoBlockStmt()
         : Expression(ExprType::DO_BLOCK) {}
 };
 
 /// ANALYZE statement
 struct AnalyzeStmt : Expression {
-    std::string table;                            // Optional table name
+    std::string table;                            // Primary table name
+    std::vector<std::string> tables;              // Multiple tables (if supported)
     std::vector<std::string> columns;             // Optional column list
+    bool verbose = false;                         // VERBOSE option
+    bool local = false;                           // LOCAL option (MySQL)
+    bool no_write_to_binlog = false;              // NO_WRITE_TO_BINLOG (MySQL)
+    bool has_table_keyword = false;               // Was TABLE keyword used? (MySQL)
 
     AnalyzeStmt()
         : Expression(ExprType::ANALYZE_STMT) {}
 };
 
 /// VACUUM statement (PostgreSQL-specific)
 struct VacuumStmt : Expression {
-    std::string table;                            // Optional table name
+    std::string table;                            // Primary table name
+    std::vector<std::string> tables;              // Multiple tables (if supported)
     std::vector<std::string> columns;             // Optional column list (requires ANALYZE)
 
     // Boolean options
@@ -1159,7 +1168,7 @@ struct VacuumStmt : Expression {
     IndexCleanup index_cleanup = IndexCleanup::AUTO;
 
     // Use parenthesized syntax (PostgreSQL 9.0+) vs legacy syntax
-    bool use_parenthesized_syntax = true;
+    bool use_parenthesized_syntax = false;        // Default to legacy syntax
 
     VacuumStmt()
         : Expression(ExprType::VACUUM_STMT) {}

include/libsqlglot/generator.h

@@ -1646,24 +1646,66 @@ class Generator {
 
     void visit_do_block(const DoBlockStmt* stmt) {
         sql_ << "DO";
-        if (!stmt->language.empty() && stmt->language != "plpgsql") {
+        if (stmt->language_explicit && !stmt->language.empty()) {
             sql_ << " LANGUAGE " << stmt->language;
         }
-        sql_ << " $$";
-        for (auto* s : stmt->statements) {
+
+        // Use raw_body if available (from dollar-quoted strings)
+        if (!stmt->raw_body.empty()) {
             sql_ << " ";
-            visit(s);
-            sql_ << ";";
+            if (!stmt->delimiter.empty()) {
+                sql_ << stmt->delimiter;
+            } else {
+                sql_ << "$$";
+            }
+            sql_ << stmt->raw_body;
+            if (!stmt->delimiter.empty()) {
+                sql_ << stmt->delimiter;
+            } else {
+                sql_ << "$$";
+            }
+        } else {
+            // Fallback to parsed statements
+            sql_ << " $$";
+            for (auto* s : stmt->statements) {
+                sql_ << " ";
+                visit(s);
+                sql_ << ";";
+            }
+            sql_ << " $$";
         }
-        sql_ << " $$";
     }
 
     void visit_analyze(const AnalyzeStmt* stmt) {
         sql_ << "ANALYZE";
-        if (!stmt->table.empty()) {
-            sql_ << " TABLE " << stmt->table;
+
+        // MySQL options: LOCAL or NO_WRITE_TO_BINLOG
+        if (stmt->local) {
+            sql_ << " LOCAL";
+        } else if (stmt->no_write_to_binlog) {
+            sql_ << " NO_WRITE_TO_BINLOG";
+        }
+
+        // PostgreSQL option: VERBOSE
+        if (stmt->verbose) {
+            sql_ << " VERBOSE";
+        }
+
+        // MySQL: TABLE keyword
+        if (stmt->has_table_keyword) {
+            sql_ << " TABLE";
+        }
+
+        // Table names (comma-separated)
+        if (!stmt->tables.empty()) {
+            for (size_t i = 0; i < stmt->tables.size(); ++i) {
+                if (i > 0) sql_ << ",";
+                sql_ << " " << stmt->tables[i];
+            }
+
+            // Column list (only on first table)
             if (!stmt->columns.empty()) {
-                sql_ << " (";
+                sql_ << "(";
                 for (size_t i = 0; i < stmt->columns.size(); ++i) {
                     if (i > 0) sql_ << ", ";
                     sql_ << stmt->columns[i];
@@ -1741,13 +1783,16 @@ class Generator {
             if (stmt->analyze) sql_ << " ANALYZE";
         }
 
-        // Table name
-        if (!stmt->table.empty()) {
-            sql_ << " " << stmt->table;
+        // Table names (comma-separated)
+        if (!stmt->tables.empty()) {
+            for (size_t i = 0; i < stmt->tables.size(); ++i) {
+                if (i > 0) sql_ << ",";
+                sql_ << " " << stmt->tables[i];
+            }
 
-            // Column list (only with ANALYZE)
-            if (stmt->analyze && !stmt->columns.empty()) {
-                sql_ << " (";
+            // Column list (allowed with or without ANALYZE)
+            if (!stmt->columns.empty()) {
+                sql_ << "(";
                 for (size_t i = 0; i < stmt->columns.size(); ++i) {
                     if (i > 0) sql_ << ", ";
                     sql_ << stmt->columns[i];
@@ -1780,7 +1825,7 @@ class Generator {
             case GrantStmt::PrivilegeType::CREATEDB: return "CREATEDB";
             case GrantStmt::PrivilegeType::REPLICATION: return "REPLICATION";
             case GrantStmt::PrivilegeType::BYPASSRLS: return "BYPASSRLS";
-            case GrantStmt::PrivilegeType::ALL: return "ALL PRIVILEGES";
+            case GrantStmt::PrivilegeType::ALL: return "ALL";
             case GrantStmt::PrivilegeType::ALL_PRIVILEGES: return "ALL PRIVILEGES";
             case GrantStmt::PrivilegeType::INDEX: return "INDEX";
             case GrantStmt::PrivilegeType::DEBUG: return "DEBUG";