no more mysql

weed/query/engine/sql_parser_config.go

@@ -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{