Client (psql, pgx, JDBC, ORM)
    |
    v
pkg/pgsql/server/         -- PostgreSQL v3 wire protocol
    |
    v
embedded/sql/engine.go    -- SQL engine (parse, plan, execute)
embedded/sql/stmt.go      -- AST nodes and statement execution
embedded/sql/sql_grammar.y -- Yacc grammar (generates sql_parser.go)
embedded/sql/parser.go    -- Lexer and keyword mapping
embedded/sql/catalog.go   -- Schema metadata (tables, columns, indexes)
embedded/sql/functions.go -- Built-in SQL functions
    |
    v
embedded/store/           -- Immutable key-value store with Merkle trees

// SQLStmt — any executable SQL statement
type SQLStmt interface {
    readOnly() bool
    requiredPrivileges() []SQLPrivilege
    execAt(ctx, tx, params) (*SQLTx, error)
    inferParameters(ctx, tx, params)
}

// DataSource — a statement that returns rows (SELECT, UNION, CTE, RETURNING)
type DataSource interface {
    SQLStmt
    Resolve(ctx, tx, params, scanSpecs) (RowReader, error)
    Alias() string
}

// Function — a built-in SQL function
type Function interface {
    InferType(cols, params, implicitTable) (SQLValueType, error)
    RequiresType(t, cols, params, implicitTable) error
    Apply(tx *SQLTx, params []TypedValue) (TypedValue, error)
}

// TableResolver — virtual table (pg_catalog, views, CTEs)
type TableResolver interface {
    Table() string
    Resolve(ctx, tx, alias) (RowReader, error)
}

const (
    // ... existing constants ...
    MyNewFnCall string = "MY_NEW_FN"
)

type myNewFn struct{}

func (f *myNewFn) InferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
    return VarcharType, nil // return type
}

func (f *myNewFn) RequiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
    if t != VarcharType {
        return fmt.Errorf("%w: %v can not be interpreted as type %v", ErrInvalidTypes, VarcharType, t)
    }
    return nil
}

func (f *myNewFn) Apply(tx *SQLTx, params []TypedValue) (TypedValue, error) {
    if len(params) != 1 {
        return nil, fmt.Errorf("%w: '%s' expects 1 argument", ErrIllegalArguments, MyNewFnCall)
    }
    if params[0].IsNull() {
        return NewNull(VarcharType), nil
    }
    // ... implement logic ...
    return NewVarchar(result), nil
}

var builtinFunctions = map[string]Function{
    // ... existing entries ...
    MyNewFnCall: &myNewFn{},
}

var keywords = map[string]int{
    // ... existing keywords ...
    "MYNEWKW": MYNEWKW,
}

%token <keyword> ... MYNEWKW

my_new_stmt:
    MYNEWKW IDENTIFIER
    {
        $$ = &MyNewStmt{name: $2}
    }

type MyNewStmt struct {
    name string
}

func (stmt *MyNewStmt) readOnly() bool                     { return true }
func (stmt *MyNewStmt) requiredPrivileges() []SQLPrivilege { return nil }

func (stmt *MyNewStmt) inferParameters(ctx context.Context, tx *SQLTx, params map[string]SQLValueType) error {
    return nil
}

func (stmt *MyNewStmt) execAt(ctx context.Context, tx *SQLTx, params map[string]interface{}) (*SQLTx, error) {
    // ... implement execution ...
    return tx, nil
}

go run golang.org/x/tools/cmd/goyacc -l -o embedded/sql/sql_parser.go embedded/sql/sql_grammar.y

var myTableCols = []sql.ColDescriptor{
    {Column: "col1", Type: sql.IntegerType},
    {Column: "col2", Type: sql.VarcharType},
}

type myTableResolver struct{}

func (r *myTableResolver) Table() string { return "my_table" }

func (r *myTableResolver) Resolve(ctx context.Context, tx *sql.SQLTx, alias string) (sql.RowReader, error) {
    catalog := tx.Catalog()
    tables := catalog.GetTables()

    var rows [][]sql.ValueExp
    for _, t := range tables {
        rows = append(rows, []sql.ValueExp{
            sql.NewInteger(int64(t.ID())),
            sql.NewVarchar(t.Name()),
        })
    }

    return sql.NewValuesRowReader(tx, nil, myTableCols, true, alias, rows)
}

var tableResolvers = []sql.TableResolver{
    // ... existing resolvers ...
    &myTableResolver{},
}

var showSettings = map[string]string{
    // ... existing settings ...
    "my_setting": "my_value",
}

var myFuncRe = regexp.MustCompile(`(?i)select\s+my_func\(\s*\)`)

func TestMyNewFeature(t *testing.T) {
    engine := setupCommonTest(t)
    
    _, _, err := engine.Exec(context.Background(), nil,
        `CREATE TABLE test (id INTEGER, PRIMARY KEY id)`, nil)
    require.NoError(t, err)
    
    r, err := engine.Query(context.Background(), nil,
        `SELECT MY_NEW_FN('input')`, nil)
    require.NoError(t, err)
    row, err := r.Read(context.Background())
    require.NoError(t, err)
    require.Equal(t, expectedValue, row.ValuesByPosition[0].RawValue())
    r.Close()
}

func TestPgsqlCompat_MyFeature(t *testing.T) {
    _, port := setupTestServer(t)

    conn, err := pgx.Connect(context.Background(),
        fmt.Sprintf("host=localhost port=%d sslmode=disable user=immudb dbname=defaultdb password=immudb", port))
    require.NoError(t, err)
    defer conn.Close(context.Background())

    // Test through actual PG wire protocol
    rows, err := conn.Query(context.Background(), "SELECT MY_NEW_FN('test')")
    require.NoError(t, err)
    require.True(t, rows.Next())
    rows.Close()
}

# SQL engine tests
go test ./embedded/sql/ -count=1 -short -timeout 300s

# PG wire protocol tests
go test ./pkg/pgsql/... -count=1 -short -timeout 120s

# pg_catalog/information_schema resolver tests
go test ./pkg/pgsql/pgschema/ -count=1 -v

# Full test suite (all packages)
go test ./embedded/... ./pkg/... -count=1 -short -timeout 600s

# Specific feature tests
go test ./embedded/sql/ -run "TestWindowFunctions" -count=1 -v

# PG wire integration tests only
go test ./pkg/pgsql/server/ -run "TestPgsqlCompat_" -count=1 -v