|  |  | @ -7,85 +7,32 @@ import ( | 
			
		
	
		
			
				
					|  |  |  | 	"time" | 
			
		
	
		
			
				
					|  |  |  | ) | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // SQLParserConfig controls which SQL parser to use
 | 
			
		
	
		
			
				
					|  |  |  | // SQLParserConfig controls SQL parsing behavior (PostgreSQL syntax only)
 | 
			
		
	
		
			
				
					|  |  |  | type SQLParserConfig struct { | 
			
		
	
		
			
				
					|  |  |  | 	UsePostgreSQLParser   bool // If true, use pg_query_go; if false, use mysql-dialect parser
 | 
			
		
	
		
			
				
					|  |  |  | 	EnableDialectWarnings bool // If true, log warnings about dialect mismatches
 | 
			
		
	
		
			
				
					|  |  |  | 	// Currently only PostgreSQL syntax is supported
 | 
			
		
	
		
			
				
					|  |  |  | 	// This struct is kept for future extensibility
 | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // DefaultSQLParserConfig returns the default configuration (MySQL parser for now)
 | 
			
		
	
		
			
				
					|  |  |  | func DefaultSQLParserConfig() *SQLParserConfig { | 
			
		
	
		
			
				
					|  |  |  | 	return &SQLParserConfig{ | 
			
		
	
		
			
				
					|  |  |  | 		UsePostgreSQLParser:   false, // Keep MySQL parser as default for stability
 | 
			
		
	
		
			
				
					|  |  |  | 		EnableDialectWarnings: true,  // Enable warnings about dialect issues
 | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // PostgreSQLSQLParserConfig returns configuration for PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | // PostgreSQLSQLParserConfig returns the default configuration (PostgreSQL only)
 | 
			
		
	
		
			
				
					|  |  |  | func PostgreSQLSQLParserConfig() *SQLParserConfig { | 
			
		
	
		
			
				
					|  |  |  | 	return &SQLParserConfig{ | 
			
		
	
		
			
				
					|  |  |  | 		UsePostgreSQLParser:   true, | 
			
		
	
		
			
				
					|  |  |  | 		EnableDialectWarnings: false, // No warnings needed when using correct parser
 | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 	return &SQLParserConfig{} | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // ParseSQL is a unified interface that can use either parser based on configuration
 | 
			
		
	
		
			
				
					|  |  |  | // ParseSQL parses SQL using PostgreSQL syntax
 | 
			
		
	
		
			
				
					|  |  |  | func (config *SQLParserConfig) ParseSQL(sql string) (Statement, error) { | 
			
		
	
		
			
				
					|  |  |  | 	if config.UsePostgreSQLParser { | 
			
		
	
		
			
				
					|  |  |  | 		return config.parseWithPostgreSQL(sql) | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 	return config.parseWithMySQL(sql) | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // parseWithMySQL uses the PostgreSQL parser (fallback for backward compatibility)
 | 
			
		
	
		
			
				
					|  |  |  | func (config *SQLParserConfig) parseWithMySQL(sql string) (Statement, error) { | 
			
		
	
		
			
				
					|  |  |  | 	if config.EnableDialectWarnings { | 
			
		
	
		
			
				
					|  |  |  | 		config.checkForPostgreSQLDialectFeatures(sql) | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	// Since we've removed the MySQL parser, use the PostgreSQL parser instead
 | 
			
		
	
		
			
				
					|  |  |  | 	// This maintains backward compatibility while using the better parser
 | 
			
		
	
		
			
				
					|  |  |  | 	return config.parseWithPostgreSQL(sql) | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // parseWithPostgreSQL uses the new PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | func (config *SQLParserConfig) parseWithPostgreSQL(sql string) (Statement, error) { | 
			
		
	
		
			
				
					|  |  |  | 	// Use the PostgreSQL parser from engine.go
 | 
			
		
	
		
			
				
					|  |  |  | 	return ParseSQL(sql) | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // checkForPostgreSQLDialectFeatures logs warnings for PostgreSQL-specific syntax
 | 
			
		
	
		
			
				
					|  |  |  | func (config *SQLParserConfig) checkForPostgreSQLDialectFeatures(sql string) { | 
			
		
	
		
			
				
					|  |  |  | 	sqlUpper := strings.ToUpper(sql) | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	// Check for PostgreSQL-specific features
 | 
			
		
	
		
			
				
					|  |  |  | 	if strings.Contains(sql, "\"") && !strings.Contains(sql, "'") { | 
			
		
	
		
			
				
					|  |  |  | 		fmt.Printf("WARNING: Detected double-quoted identifiers (\") - PostgreSQL uses these, MySQL uses backticks (`)\n") | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	if strings.Contains(sqlUpper, "||") && !strings.Contains(sqlUpper, "CONCAT") { | 
			
		
	
		
			
				
					|  |  |  | 		fmt.Printf("WARNING: Detected || string concatenation - PostgreSQL syntax, MySQL uses CONCAT()\n") | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	if strings.Contains(sqlUpper, "PG_") || strings.Contains(sqlUpper, "INFORMATION_SCHEMA") { | 
			
		
	
		
			
				
					|  |  |  | 		fmt.Printf("WARNING: Detected PostgreSQL system functions/catalogs - may not work with MySQL parser\n") | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	if strings.Contains(sqlUpper, "LIMIT") && strings.Contains(sqlUpper, "OFFSET") { | 
			
		
	
		
			
				
					|  |  |  | 		fmt.Printf("WARNING: LIMIT/OFFSET syntax may differ between PostgreSQL and MySQL\n") | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // SQLEngineWithParser extends SQLEngine with configurable parser
 | 
			
		
	
		
			
				
					|  |  |  | // SQLEngineWithParser extends SQLEngine with PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | type SQLEngineWithParser struct { | 
			
		
	
		
			
				
					|  |  |  | 	*SQLEngine | 
			
		
	
		
			
				
					|  |  |  | 	ParserConfig *SQLParserConfig | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // NewSQLEngineWithParser creates a new SQLEngine with parser configuration
 | 
			
		
	
		
			
				
					|  |  |  | // NewSQLEngineWithParser creates a new SQLEngine with PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | func NewSQLEngineWithParser(masterAddr string, config *SQLParserConfig) *SQLEngineWithParser { | 
			
		
	
		
			
				
					|  |  |  | 	if config == nil { | 
			
		
	
		
			
				
					|  |  |  | 		config = DefaultSQLParserConfig() | 
			
		
	
		
			
				
					|  |  |  | 		config = PostgreSQLSQLParserConfig() | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	return &SQLEngineWithParser{ | 
			
		
	
	
		
			
				
					|  |  | @ -94,7 +41,7 @@ func NewSQLEngineWithParser(masterAddr string, config *SQLParserConfig) *SQLEngi | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | } | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | // ExecuteSQL overrides the base ExecuteSQL to use the configured parser
 | 
			
		
	
		
			
				
					|  |  |  | // ExecuteSQL overrides the base ExecuteSQL to use PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | func (e *SQLEngineWithParser) ExecuteSQL(ctx context.Context, sql string) (*QueryResult, error) { | 
			
		
	
		
			
				
					|  |  |  | 	// Clean up the SQL
 | 
			
		
	
		
			
				
					|  |  |  | 	sql = strings.TrimSpace(sql) | 
			
		
	
	
		
			
				
					|  |  | @ -119,7 +66,7 @@ func (e *SQLEngineWithParser) ExecuteSQL(ctx context.Context, sql string) (*Quer | 
			
		
	
		
			
				
					|  |  |  | 		return e.handleDescribeCommand(ctx, sqlTrimmed) | 
			
		
	
		
			
				
					|  |  |  | 	} | 
			
		
	
		
			
				
					|  |  |  | 
 | 
			
		
	
		
			
				
					|  |  |  | 	// Parse the SQL statement using the configured parser
 | 
			
		
	
		
			
				
					|  |  |  | 	// Parse the SQL statement using PostgreSQL parser
 | 
			
		
	
		
			
				
					|  |  |  | 	stmt, err := e.ParserConfig.ParseSQL(sql) | 
			
		
	
		
			
				
					|  |  |  | 	if err != nil { | 
			
		
	
		
			
				
					|  |  |  | 		return &QueryResult{ | 
			
		
	
	
		
			
				
					|  |  | 
 |