Method convertQuery

pgserver/connection_handler.go:1235–1298

convertQuery takes the given Postgres query, and converts it as a list of ast.ConvertedStatement that will work with the handler.

(query string, modifiers ...QueryModifier)

// convertQuery takes the given Postgres query, and converts it as a list of ast.ConvertedStatement that will work with the handler.
func (h *ConnectionHandler) convertQuery(query string, modifiers ...QueryModifier) ([]ConvertedStatement, error) {
	for _, modifier := range modifiers {
		query = modifier(query)
	}

	// Check if the query is a subscription query, and if so, parse it as a subscription query.
	subscriptionConfig, err := parseSubscriptionSQL(query)
	if subscriptionConfig != nil && err == nil {
		return []ConvertedStatement{{
			String:             query,
			PgParsable:         true,
			SubscriptionConfig: subscriptionConfig,
		}}, nil
	}

	// Check if the query is a backup/restore query, and if so, parse it as a backup/restore query.
	backupConfig, err := parseBackupSQL(query)
	if backupConfig != nil && err == nil {
		return []ConvertedStatement{{
			String:       query,
			PgParsable:   true,
			BackupConfig: backupConfig,
		}}, nil
	}
	restoreConfig, err := parseRestoreSQL(query)
	if restoreConfig != nil && err == nil {
		return []ConvertedStatement{{
			String:        query,
			PgParsable:    true,
			RestoreConfig: restoreConfig,
		}}, nil
	}

	stmts, err := parser.Parse(query)
	if err != nil {
		// DuckDB syntax is not fully compatible with PostgreSQL, so we need to handle some queries differently.
		stmts, _ = parser.Parse("SELECT 'SQL syntax is incompatible with PostgreSQL' AS error")
		return []ConvertedStatement{{
			String:     query,
			AST:        stmts[0].AST,
			Tag:        GuessStatementTag(query),
			PgParsable: false,
		}}, nil
	}

	if len(stmts) == 0 {
		return []ConvertedStatement{{String: query}}, nil
	}

	convertedStmts := make([]ConvertedStatement, len(stmts))
	for i, stmt := range stmts {
		// Check if the query is a full match query, and if so, handle it as a full match query.
		fullMatchQuery := handleFullMatchQuery(stmt.SQL)
		if fullMatchQuery != "" {
			convertedStmts[i].String = fullMatchQuery
		} else {
			convertedStmts[i].String = stmt.SQL
		}