diff --git a/CHANGELOG.md b/CHANGELOG.md
index 835bc84cd..8d6160c75 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Performance
+- **`Transpile`** recovers most of the v1.17.0 correctness cost: the AST walks
+  follow cached per-type reflection plans that skip fields which cannot hold a
+  rewrite target, and cheap source checks skip the `||`, string-literal and
+  identifier-requoting passes when the SQL cannot need them. A short MySQL
+  `CREATE TABLE` to PostgreSQL goes from 5.2 µs to 2.7 µs (52 to 43
+  allocations); wide `OR`/`AND` chains are about 68% faster and `||` chains
+  about 55% faster. Output and errors are unchanged on 955,476 differential
+  cases. (#889)
+
 ## [1.17.0] - 2026-10-29 — Real-World Dialect Corpus, Dialect-Faithful Round Trips, Security Scanner & LSP Hardening
 
 Covers everything merged since v1.16.0, mostly the October 2026 dialect audit:
diff --git a/CLAUDE.md b/CLAUDE.md
index 590045925..e4ee669b5 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -58,7 +58,7 @@ metrics    → (no deps)
 keywords   → (no deps)
 token      → (no deps)
 tokenizer  → models, errors, metrics, keywords
-ast        → models, metrics
+ast        → models, metrics, internal/reflplan
 parser     → models, errors, keywords, token, tokenizer, ast
 
 # Higher-level / product packages
diff --git a/pkg/internal/reflplan/reflplan.go b/pkg/internal/reflplan/reflplan.go
new file mode 100644
index 000000000..f401b44ec
--- /dev/null
+++ b/pkg/internal/reflplan/reflplan.go
@@ -0,0 +1,125 @@
+// Package reflplan precomputes, per reflect.Type, which parts of a value can
+// hold an interface value. Reflective AST walkers use it to skip strings,
+// numbers, positions and other leaf data without calling reflect.Type.Field
+// on every visit. Plans are immutable once published and safe for concurrent
+// use. Reach is the least fixpoint over the reachable type graph, seeded by
+// interface kinds. Only exported struct fields participate; Fields contains
+// exactly those that reach an interface, in declaration order. Pointer, slice,
+// array (including zero-length arrays) and map plans always have Elem set.
+// Plans are fully built before LoadOrStore publishes them and never mutated
+// afterwards. Walkers prune only interface-free static types: every rewrite
+// site is an interface slot, and BinaryExpression, UnaryExpression, FunctionCall,
+// ParenthesizedExpression and LiteralValue all reach one. Reachable slots keep
+// their original visit order.
+package reflplan
+
+import (
+	"reflect"
+	"sync"
+)
+
+// Plan describes how to traverse values of one type.
+type Plan struct {
+	Type reflect.Type
+	Kind reflect.Kind
+	// Reach reports whether a value of this type can (transitively, through
+	// exported fields, elements, pointers or interfaces) hold an interface.
+	Reach bool
+	// Fields lists the exported struct fields whose type Reaches, in
+	// declaration order.
+	Fields []Field
+	// Elem is the element plan of a pointer, slice, array or map.
+	Elem *Plan
+}
+
+// Field is one exported struct field worth visiting.
+type Field struct {
+	Index int
+	Plan  *Plan
+}
+
+var cache sync.Map // reflect.Type -> *Plan
+
+// Of returns the plan for t, building it (and the plans of every type
+// reachable from t) on first use.
+func Of(t reflect.Type) *Plan {
+	if p, ok := cache.Load(t); ok {
+		if plan, ok := p.(*Plan); ok {
+			return plan
+		}
+	}
+	return build(t)
+}
+
+type rawField struct {
+	index int
+	t     reflect.Type
+}
+
+func build(root reflect.Type) *Plan {
+	local := map[reflect.Type]*Plan{}
+	raw := map[*Plan][]rawField{}
+	var order []*Plan
+	var get func(t reflect.Type) *Plan
+	get = func(t reflect.Type) *Plan {
+		if p, ok := local[t]; ok {
+			return p
+		}
+		if p, ok := cache.Load(t); ok {
+			if plan, ok := p.(*Plan); ok {
+				local[t] = plan
+				return plan
+			}
+		}
+		p := &Plan{Type: t, Kind: t.Kind(), Reach: t.Kind() == reflect.Interface}
+		local[t] = p
+		order = append(order, p)
+		switch t.Kind() {
+		case reflect.Pointer, reflect.Slice, reflect.Array, reflect.Map:
+			p.Elem = get(t.Elem())
+		case reflect.Struct:
+			var fs []rawField
+			for i := 0; i < t.NumField(); i++ {
+				if sf := t.Field(i); sf.IsExported() {
+					fs = append(fs, rawField{i, sf.Type})
+					get(sf.Type)
+				}
+			}
+			raw[p] = fs
+		}
+		return p
+	}
+	rootPlan := get(root)
+	// Least fixpoint of Reach over the (possibly cyclic) type graph.
+	for changed := true; changed; {
+		changed = false
+		for _, p := range order {
+			if p.Reach {
+				continue
+			}
+			switch p.Kind {
+			case reflect.Pointer, reflect.Slice, reflect.Array, reflect.Map:
+				p.Reach = p.Elem.Reach
+			case reflect.Struct:
+				for _, f := range raw[p] {
+					if local[f.t].Reach {
+						p.Reach = true
+						break
+					}
+				}
+			}
+			changed = changed || p.Reach
+		}
+	}
+	for _, p := range order {
+		for _, f := range raw[p] {
+			if fp := local[f.t]; fp.Reach {
+				p.Fields = append(p.Fields, Field{Index: f.index, Plan: fp})
+			}
+		}
+	}
+	for _, p := range order {
+		cache.LoadOrStore(p.Type, p)
+	}
+	return rootPlan
+}
diff --git a/pkg/internal/reflplan/reflplan_test.go b/pkg/internal/reflplan/reflplan_test.go
new file mode 100644
index 000000000..f3a629ba1
--- /dev/null
+++ b/pkg/internal/reflplan/reflplan_test.go
@@ -0,0 +1,135 @@
+package reflplan
+
+import (
+	"reflect"
+	"sync"
+	"testing"
+)
+
+type leaf struct {
+	A string
+	B int
+	C struct{ X, Y int }
+}
+type selfLeaf struct {
+	Name string
+	Next *selfLeaf
+}
+type withIface struct {
+	Name string
+	E    any
+	L    leaf
+	S    []leaf
+	M    map[string]any
+	P    *selfLeaf
+	//lint:ignore U1000 an unexported interface field must be excluded from Fields
+	hid any
+}
+type cycA struct {
+	B *cycB
+	N int
+}
+type cycB struct {
+	A   []cycA
+	Val any
+}
+
+type Embedded struct{ Value any }
+
+func TestPlanContainers(t *testing.T) {
+	for _, value := range []any{map[string]any{}, []any{}, [0]any{}, (*any)(nil)} {
+		typ := reflect.TypeOf(value)
+		p := Of(typ)
+		if !p.Reach || p.Elem == nil || !p.Elem.Reach || p.Elem.Type != typ.Elem() {
+			t.Errorf("%v: incomplete container plan: %+v", typ, p)
+		}
+	}
+	// Only map values carry rewrite slots; interface keys do not reach.
+	for _, value := range []any{map[any]int{}, []leaf{}, [0]leaf{}, (*selfLeaf)(nil)} {
+		typ := reflect.TypeOf(value)
+		p := Of(typ)
+		if p.Reach || p.Elem == nil || p.Elem.Reach || p.Elem.Type != typ.Elem() {
+			t.Errorf("%v: invalid leaf container plan: %+v", typ, p)
+		}
+	}
+	typ := reflect.TypeOf(struct {
+		Before int
+		Embedded
+		After string
+	}{})
+	p := Of(typ)
+	if !p.Reach || !reflect.DeepEqual(indices(p), []int{1}) || !reflect.DeepEqual(indices(p.Fields[0].Plan), []int{0}) {
+		t.Fatalf("embedded plan = %+v", p)
+	}
+	if Of(reflect.TypeOf(struct{ hidden any }{})).Reach {
+		t.Fatal("unexported interface field must not reach")
+	}
+}
+
+func indices(p *Plan) []int {
+	var out []int
+	for _, f := range p.Fields {
+		out = append(out, f.Index)
+	}
+	return out
+}
+
+func TestPlans(t *testing.T) {
+	if Of(reflect.TypeOf(leaf{})).Reach || Of(reflect.TypeOf(selfLeaf{})).Reach {
+		t.Fatal("interface-free types must not reach")
+	}
+	p := Of(reflect.TypeOf(withIface{}))
+	if !p.Reach || !reflect.DeepEqual(indices(p), []int{1, 4}) {
+		t.Fatalf("withIface fields = %v", indices(p))
+	}
+	a := Of(reflect.TypeOf(&cycA{}))
+	if !a.Reach || !a.Elem.Reach || !reflect.DeepEqual(indices(a.Elem), []int{0}) {
+		t.Fatalf("cycA = %+v", a.Elem)
+	}
+	b := a.Elem.Fields[0].Plan
+	if b.Elem == nil || !b.Reach || !reflect.DeepEqual(indices(b.Elem), []int{0, 1}) {
+		t.Fatalf("cycB = %+v", b)
+	}
+	back := b.Elem.Fields[0].Plan
+	if back.Elem == nil || back.Elem.Type != reflect.TypeOf(cycA{}) || !back.Reach {
+		t.Fatalf("cycle back edge = %+v", back)
+	}
+}
+
+func TestConcurrentBuild(t *testing.T) {
+	// Unique types exercise cold-cache publication even after TestPlans.
+	type concurrentA struct {
+		Next  *concurrentA
+		Value any
+	}
+	typ := reflect.TypeOf(struct{ A []map[int]*concurrentA }{})
+	start := make(chan struct{})
+	var wg sync.WaitGroup
+	for i := 0; i < 32; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			<-start
+			for range 32 {
+				p := Of(typ)
+				if !p.Reach || !reflect.DeepEqual(indices(p), []int{0}) {
+					t.Errorf("incomplete published plan: %+v", p)
+					return
+				}
+				elem := p.Fields[0].Plan
+				for _, kind := range []reflect.Kind{reflect.Slice, reflect.Map, reflect.Pointer} {
+					if elem.Kind != kind || elem.Elem == nil || !elem.Reach {
+						t.Errorf("incomplete container plan: %+v", elem)
+						return
+					}
+					elem = elem.Elem
+				}
+				if elem.Kind != reflect.Struct || !elem.Reach || !reflect.DeepEqual(indices(elem), []int{0, 1}) {
+					t.Errorf("incomplete cycle plan: %+v", elem)
+				}
+			}
+		}()
+	}
+	close(start)
+	wg.Wait()
+}
diff --git a/pkg/sql/ast/reflplan_coverage_test.go b/pkg/sql/ast/reflplan_coverage_test.go
new file mode 100644
index 000000000..00abf955c
--- /dev/null
+++ b/pkg/sql/ast/reflplan_coverage_test.go
@@ -0,0 +1,203 @@
+// Copyright 2026 GoSQLX Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package ast
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
+)
+
+// Each independent search has its own visited set, so a failed search through
+// a cycle cannot hide a different path to an interface. Unlike reflplan this
+// uses ordinary graph search, not propagation of Reach through a fixpoint.
+func naiveTypeReachesInterface(typ reflect.Type, seen map[reflect.Type]bool) bool {
+	if seen[typ] {
+		return false
+	}
+	seen[typ] = true
+	switch typ.Kind() {
+	case reflect.Interface:
+		return true
+	case reflect.Pointer, reflect.Slice, reflect.Array, reflect.Map:
+		return naiveTypeReachesInterface(typ.Elem(), seen)
+	case reflect.Struct:
+		for i := range typ.NumField() {
+			f := typ.Field(i)
+			if f.IsExported() && naiveTypeReachesInterface(f.Type, seen) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func TestReflectionPlanASTCoverage(t *testing.T) {
+	visited := map[reflect.Type]bool{}
+	var check func(reflect.Type)
+	check = func(typ reflect.Type) {
+		if visited[typ] {
+			return
+		}
+		visited[typ] = true
+		p := reflplan.Of(typ)
+		wantReach := naiveTypeReachesInterface(typ, map[reflect.Type]bool{})
+		if p.Type != typ || p.Kind != typ.Kind() || p.Reach != wantReach {
+			t.Errorf("%v: metadata/reach mismatch: %+v, want Reach=%v", typ, p, wantReach)
+		}
+		switch typ.Kind() {
+		case reflect.Pointer, reflect.Slice, reflect.Array, reflect.Map:
+			if p.Elem == nil || p.Elem.Type != typ.Elem() {
+				t.Errorf("%v: missing/wrong element plan", typ)
+			}
+			check(typ.Elem())
+		case reflect.Struct:
+			var want []int
+			for i := range typ.NumField() {
+				f := typ.Field(i)
+				if f.IsExported() && naiveTypeReachesInterface(f.Type, map[reflect.Type]bool{}) {
+					want = append(want, i)
+				}
+				check(f.Type)
+			}
+			var got []int
+			for _, f := range p.Fields {
+				got = append(got, f.Index)
+				if f.Index < 0 || f.Index >= typ.NumField() {
+					t.Errorf("%v: invalid index %d", typ, f.Index)
+					continue
+				}
+				if f.Plan == nil || f.Plan.Type != typ.Field(f.Index).Type {
+					t.Errorf("%v field %d: wrong plan", typ, f.Index)
+				}
+			}
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("%v: planned fields %v, want %v", typ, got, want)
+			}
+		}
+	}
+	for _, c := range childrenCoverageCases() {
+		check(c.typ)
+	}
+	for _, value := range []any{BinaryExpression{}, UnaryExpression{}, FunctionCall{}, ParenthesizedExpression{}, LiteralValue{}} {
+		typ := reflect.TypeOf(value)
+		check(typ)
+		if !reflplan.Of(typ).Reach {
+			t.Errorf("matched rewrite type %v must reach an interface", typ)
+		}
+	}
+}
+
+func TestRetargetScratchSharedPointersTwice(t *testing.T) {
+	abs := &UnaryExpression{Operator: PGAbs, Expr: &Identifier{Name: "a"}}
+	shared := &BinaryExpression{Left: abs, Operator: "+", Right: &LiteralValue{Type: "number", Value: 1}}
+	stmt := &SelectStatement{Columns: []Expression{shared, shared}}
+	for run := range 2 {
+		// Reuse the same addresses. Stale seen entries would skip the inner
+		// unary slot on the second call, even if outer slots were visited.
+		shared.Left = abs
+		if err := RetargetOperators(stmt, "postgresql", "mysql"); err != nil {
+			t.Fatal(err)
+		}
+		call, ok := shared.Left.(*FunctionCall)
+		if !ok || call.Name != "ABS" || len(call.Arguments) != 1 || call.Arguments[0] != abs.Expr {
+			t.Fatalf("run %d: shared child not rewritten: %#v", run, shared.Left)
+		}
+		if stmt.Columns[0] != shared || stmt.Columns[1] != shared {
+			t.Fatalf("run %d: shared tree identity changed", run)
+		}
+	}
+}
+
+func TestRetargetScratchReset(t *testing.T) {
+	for _, tc := range []struct {
+		name           string
+		seen, capacity int
+		wantKeep       bool
+	}{
+		{"empty", 0, 0, true},
+		{"at_limit", 4096, 4096, true},
+		{"seen_over_limit", 4097, 16, false},
+		{"stack_over_limit", 1, 4097, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			sc := &retargetScratch{seen: make(map[uintptr]struct{}, tc.seen), stack: make([]operatorWalkFrame, tc.capacity)}
+			for i := range tc.seen {
+				sc.seen[uintptr(i+1)] = struct{}{}
+			}
+			for i := range sc.stack {
+				// Frames still on the stack (an early return on error) hold
+				// references; reset must drop every reference-bearing field.
+				v := reflect.ValueOf(&Identifier{Name: "retained"})
+				sc.stack[i] = operatorWalkFrame{
+					value: v, plan: reflplan.Of(v.Type()), slot: v,
+					mapValue: reflect.ValueOf(map[string]Expression{}),
+					mapKey:   reflect.ValueOf("key"),
+					iter:     reflect.ValueOf(map[string]Expression{}).MapRange(),
+				}
+			}
+			if keep := sc.reset(); keep != tc.wantKeep {
+				t.Fatalf("reset retention = %v, want %v", keep, tc.wantKeep)
+			}
+			if !tc.wantKeep {
+				return
+			}
+			if len(sc.seen) != 0 || len(sc.stack) != 0 || cap(sc.stack) != tc.capacity {
+				t.Fatal("reset did not clear state while preserving reusable capacity")
+			}
+			for i, frame := range sc.stack[:cap(sc.stack)] {
+				if !reflect.DeepEqual(frame, operatorWalkFrame{}) {
+					t.Fatalf("frame %d retains state after reset", i)
+				}
+			}
+		})
+	}
+}
+
+// TestRetargetWalkZeroesPoppedFrames pins the invariant reset relies on:
+// after a successful walk no frame up to the stack's capacity still refers
+// into the AST, so reset only has to clear the live length.
+func TestRetargetWalkZeroesPoppedFrames(t *testing.T) {
+	stmt := &SelectStatement{Columns: []Expression{
+		&BinaryExpression{Left: &Identifier{Name: "a"}, Operator: "^", Right: &Identifier{Name: "b"}},
+		&FunctionCall{Name: "f", Arguments: []Expression{&Identifier{Name: "c"}}},
+	}}
+	r := operatorRetargeter{from: "mysql", to: "mysql", seen: map[uintptr]struct{}{}}
+	stack := r.walk(reflect.ValueOf(stmt), false, make([]operatorWalkFrame, 0, 64))
+	if r.err != nil {
+		t.Fatalf("walk: %v", r.err)
+	}
+	if len(stack) != 0 {
+		t.Fatalf("stack length after walk = %d, want 0", len(stack))
+	}
+	for i, frame := range stack[:cap(stack)] {
+		if !reflect.DeepEqual(frame, operatorWalkFrame{}) {
+			t.Fatalf("frame %d still holds state after a successful walk", i)
+		}
+	}
+}
+
+func TestRetargetScratchHugeThenSmall(t *testing.T) {
+	terms := 490000
+	if testing.Short() || raceEnabled {
+		terms = 5000 // Still exceeds the 4096-entry pool cap.
+	}
+	var expr Expression = &LiteralValue{Type: "number", Value: 1}
+	for range terms {
+		expr = &BinaryExpression{Left: expr, Operator: "OR", Right: &LiteralValue{Type: "number", Value: 1}}
+	}
+	if err := RetargetOperators(&SelectStatement{Columns: []Expression{expr}}, "postgresql", "mysql"); err != nil {
+		t.Fatal(err)
+	}
+	// The small rewrite must not inherit seen entries or an old frame/error.
+	small := &SelectStatement{Columns: []Expression{&UnaryExpression{Operator: PGAbs, Expr: &Identifier{Name: "a"}}}}
+	if err := RetargetOperators(small, "postgresql", "mysql"); err != nil {
+		t.Fatal(err)
+	}
+	call, ok := small.Columns[0].(*FunctionCall)
+	if !ok || call.Name != "ABS" {
+		t.Fatalf("small rewrite after huge tree: %#v", small.Columns[0])
+	}
+}
diff --git a/pkg/sql/ast/retarget_operators.go b/pkg/sql/ast/retarget_operators.go
index 9b8fe5c99..c4f09ef29 100644
--- a/pkg/sql/ast/retarget_operators.go
+++ b/pkg/sql/ast/retarget_operators.go
@@ -18,6 +18,9 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"sync"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
 )
 
 // RetargetOperators rewrites stmt in place for a target dialect. An empty
@@ -47,11 +50,47 @@ func RetargetOperators(stmt Statement, from, to string) error {
 	if (from != "" && from == to) || stmt == nil {
 		return nil
 	}
-	r := operatorRetargeter{from: normalDialect(from), to: normalDialect(to), seen: map[uintptr]struct{}{}}
-	r.walk(reflect.ValueOf(stmt), false)
+	sc, ok := retargetScratchPool.Get().(*retargetScratch)
+	if !ok || sc == nil {
+		sc = &retargetScratch{seen: make(map[uintptr]struct{}), stack: make([]operatorWalkFrame, 0, 16)}
+	}
+	// A walk that panics leaves frames in the backing array that sc.stack no
+	// longer covers, so only scratch from a completed walk is reused.
+	completed := false
+	defer func() {
+		if completed && sc.reset() {
+			retargetScratchPool.Put(sc)
+		}
+	}()
+	r := operatorRetargeter{from: normalDialect(from), to: normalDialect(to), seen: sc.seen}
+	sc.stack = r.walk(reflect.ValueOf(stmt), false, sc.stack[:0])
+	completed = true
 	return r.err
 }
 
+type retargetScratch struct {
+	seen  map[uintptr]struct{}
+	stack []operatorWalkFrame
+}
+
+// reset drops AST references before reuse. Oversized scratch is discarded
+// rather than retaining a huge chain in the pool.
+func (sc *retargetScratch) reset() bool {
+	if len(sc.seen) > 4096 || cap(sc.stack) > 4096 {
+		return false
+	}
+	clear(sc.seen)
+	// walk zeroes each frame it pops, so only frames still on the stack (an
+	// early return on error) hold reflect.Values into the AST.
+	clear(sc.stack)
+	sc.stack = sc.stack[:0]
+	return true
+}
+
+var retargetScratchPool = sync.Pool{New: func() any {
+	return &retargetScratch{seen: map[uintptr]struct{}{}, stack: make([]operatorWalkFrame, 0, 16)}
+}}
+
 // normalDialect maps the generic dialect to "" and lower-cases the name.
 func normalDialect(d string) string {
 	s := strings.ToLower(d)
@@ -86,6 +125,7 @@ const maxRetargetNesting = 512
 
 type operatorWalkFrame struct {
 	value      reflect.Value
+	plan       *reflplan.Plan
 	slot       reflect.Value
 	inOperator bool
 	nesting    int
@@ -98,10 +138,16 @@ type operatorWalkFrame struct {
 
 // walk visits exported fields in their original order using heap frames. Each
 // settable expression slot is rewritten after its children; map copies are
-// written back only after their complete subtree has been rewritten.
-func (r *operatorRetargeter) walk(v reflect.Value, inOperator bool) {
-	stack := make([]operatorWalkFrame, 1, 16)
-	stack[0] = operatorWalkFrame{value: v, inOperator: inOperator}
+// written back only after their complete subtree has been rewritten. Fields,
+// elements and map values whose static type cannot hold an interface (see
+// reflplan) are skipped: they hold no expression slot to rewrite. Pruning
+// interface-free pointers also removes them from address-only seen sets; this
+// can only visit more, never fewer, so output differs from an unpruned walk
+// only if a pruned value aliased the address of a rewrite-bearing node, which
+// the parser does not produce. stack is reused scratch (nil is fine); the
+// returned slice is the stack for the next call.
+func (r *operatorRetargeter) walk(v reflect.Value, inOperator bool, stack []operatorWalkFrame) []operatorWalkFrame {
+	stack = append(stack, operatorWalkFrame{value: v, plan: reflplan.Of(v.Type()), inOperator: inOperator})
 	for len(stack) > 0 && r.err == nil {
 		f := &stack[len(stack)-1]
 		if !f.entered {
@@ -118,58 +164,64 @@ func (r *operatorRetargeter) walk(v reflect.Value, inOperator bool) {
 						break
 					}
 					r.seen[ptr] = struct{}{}
+					f.value = f.value.Elem()
+					f.plan = f.plan.Elem
+				} else {
+					f.value = f.value.Elem()
+					f.plan = reflplan.Of(f.value.Type())
 				}
-				f.value = f.value.Elem()
 			}
 			if f.value.Kind() == reflect.Struct && r.nestsOutput(f.value) {
 				f.nesting++
 				if f.nesting > maxRetargetNesting {
 					r.err = fmt.Errorf("expression nesting too deep to transpile")
-					return
+					return stack
 				}
 			}
 		}
 		var child reflect.Value
+		var childPlan *reflplan.Plan
 		operands := false
 		switch f.value.Kind() {
 		case reflect.Struct:
-			t := f.value.Type()
-			operands = t == binaryExprType || t == unaryExprType
-			for f.index < f.value.NumField() {
-				i := f.index
+			if f.index < len(f.plan.Fields) {
+				t := f.plan.Type
+				operands = t == binaryExprType || t == unaryExprType
+				fp := f.plan.Fields[f.index]
 				f.index++
-				if t.Field(i).IsExported() {
-					child = f.value.Field(i)
-					break
-				}
+				child, childPlan = f.value.Field(fp.Index), fp.Plan
 			}
 		case reflect.Slice, reflect.Array:
-			if f.index < f.value.Len() {
-				child = f.value.Index(f.index)
+			if f.plan.Elem.Reach && f.index < f.value.Len() {
+				child, childPlan = f.value.Index(f.index), f.plan.Elem
 				f.index++
 			}
 		case reflect.Map:
-			if f.iter == nil {
-				f.iter = f.value.MapRange()
-			}
-			if f.iter.Next() {
-				child = reflect.New(f.value.Type().Elem()).Elem()
-				child.Set(f.iter.Value())
-				frame := operatorWalkFrame{value: child, slot: child, nesting: f.nesting, mapValue: f.value, mapKey: f.iter.Key()}
-				stack = append(stack, frame)
-				continue
+			if f.plan.Elem.Reach {
+				if f.iter == nil {
+					f.iter = f.value.MapRange()
+				}
+				if f.iter.Next() {
+					child = reflect.New(f.value.Type().Elem()).Elem()
+					child.Set(f.iter.Value())
+					frame := operatorWalkFrame{value: child, plan: f.plan.Elem, slot: child, nesting: f.nesting, mapValue: f.value, mapKey: f.iter.Key()}
+					stack = append(stack, frame)
+					continue
+				}
 			}
 		}
 		if child.IsValid() {
-			stack = append(stack, operatorWalkFrame{value: child, slot: child, inOperator: operands, nesting: f.nesting})
+			stack = append(stack, operatorWalkFrame{value: child, plan: childPlan, slot: child, inOperator: operands, nesting: f.nesting})
 			continue
 		}
 		r.slot(f.slot, f.inOperator)
 		if r.err == nil && f.mapValue.IsValid() {
 			f.mapValue.SetMapIndex(f.mapKey, f.slot)
 		}
+		stack[len(stack)-1] = operatorWalkFrame{}
 		stack = stack[:len(stack)-1]
 	}
+	return stack
 }
 
 // nestsOutput identifies expression boundaries rendered recursively. Ordinary
diff --git a/pkg/sql/ast/retarget_operators_deep_test.go b/pkg/sql/ast/retarget_operators_deep_test.go
index 8b99d7a53..a5eeed453 100644
--- a/pkg/sql/ast/retarget_operators_deep_test.go
+++ b/pkg/sql/ast/retarget_operators_deep_test.go
@@ -52,7 +52,7 @@ func TestRetargetOperatorsPostOrderAndMap(t *testing.T) {
 	power := &BinaryExpression{Left: &BinaryExpression{Left: a, Operator: "^", Right: b}, Operator: "^", Right: c}
 	values := map[string]Expression{"concat": concat, "power": power}
 	r := operatorRetargeter{from: "postgresql", to: "mysql", seen: map[uintptr]struct{}{}}
-	r.walk(reflect.ValueOf(values), false)
+	r.walk(reflect.ValueOf(values), false, nil)
 	if r.err != nil {
 		t.Fatal(r.err)
 	}
diff --git a/pkg/transpiler/dialect_rules.go b/pkg/transpiler/dialect_rules.go
index 2fb7b47a4..36a22f407 100644
--- a/pkg/transpiler/dialect_rules.go
+++ b/pkg/transpiler/dialect_rules.go
@@ -15,6 +15,8 @@
 package transpiler
 
 import (
+	"sync"
+
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/dialect"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 	"github.com/ajitpratap0/GoSQLX/pkg/transpiler/rules"
@@ -53,12 +55,55 @@ func register(from, to keywords.SQLDialect, rs ...RewriteRule) {
 // Cross-dialect pairs include common row-limit rules; same-dialect pairs return nil.
 // Exported for testing.
 func RulesFor(from, to keywords.SQLDialect) []RewriteRule {
+	return buildRules(from, to, true)
+}
+
+type rulesKey struct {
+	from, to keywords.SQLDialect
+	pipes    bool
+}
+
+// rulesCache is immutable after rulesCacheOnce publishes it. Only the nine
+// supported dialects are cached; arbitrary caller strings cannot grow it.
+var (
+	rulesCacheOnce sync.Once
+	rulesCache     map[rulesKey][]RewriteRule
+)
+
+func rulesForSource(from, to keywords.SQLDialect, pipes bool) []RewriteRule {
+	rulesCacheOnce.Do(func() {
+		dialects := [...]keywords.SQLDialect{
+			keywords.DialectGeneric, keywords.DialectMySQL, keywords.DialectPostgreSQL,
+			keywords.DialectSQLite, keywords.DialectSQLServer, keywords.DialectOracle,
+			keywords.DialectSnowflake, keywords.DialectClickHouse, keywords.DialectMariaDB,
+		}
+		rulesCache = make(map[rulesKey][]RewriteRule, len(dialects)*len(dialects)*2)
+		for _, f := range dialects {
+			for _, t := range dialects {
+				for _, p := range [...]bool{false, true} {
+					rulesCache[rulesKey{f, t, p}] = buildRules(f, t, p)
+				}
+			}
+		}
+	})
+	if rs, ok := rulesCache[rulesKey{from, to, pipes}]; ok {
+		// Callers must never mutate the shared slice. rowLimitRule keeps all
+		// mutable traversal state per invocation, so its closure is safe to share.
+		return rs
+	}
+	return buildRules(from, to, pipes)
+}
+
+func buildRules(from, to keywords.SQLDialect, pipes bool) []RewriteRule {
 	if from == to {
 		return nil
 	}
 	rs := ruleRegistry[dialectPair{from, to}]
 	// Never append into the registry's backing array.
 	rs = append(rs[:len(rs):len(rs)], rowLimitRule(to))
+	if !pipes {
+		return rs
+	}
 	if r := pipesRule(from, to); r != nil {
 		return append(rs, r)
 	}
@@ -80,8 +125,3 @@ func pipesRule(from, to keywords.SQLDialect) RewriteRule {
 	}
 	return nil
 }
-
-// rulesFor is the internal version used by Transpile.
-func rulesFor(from, to keywords.SQLDialect) []RewriteRule {
-	return RulesFor(from, to)
-}
diff --git a/pkg/transpiler/prefilter_test.go b/pkg/transpiler/prefilter_test.go
new file mode 100644
index 000000000..92871426b
--- /dev/null
+++ b/pkg/transpiler/prefilter_test.go
@@ -0,0 +1,341 @@
+// Copyright 2026 GoSQLX Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package transpiler
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/models"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/tokenizer"
+)
+
+func prefilterDialects() []keywords.SQLDialect {
+	return []keywords.SQLDialect{keywords.DialectGeneric, keywords.DialectPostgreSQL,
+		keywords.DialectMySQL, keywords.DialectMariaDB, keywords.DialectSQLServer,
+		keywords.DialectOracle, keywords.DialectSQLite, keywords.DialectSnowflake,
+		keywords.DialectClickHouse}
+}
+
+// Compare the exact error text as well as output, including parse failures.
+func checkPrefilterEquivalent(t *testing.T, sql string, from, to keywords.SQLDialect) {
+	t.Helper()
+	got, gotErr := transpile(sql, from, to, true)
+	want, wantErr := transpile(sql, from, to, false)
+	if got != want || fmt.Sprint(gotErr) != fmt.Sprint(wantErr) {
+		t.Fatalf("%s -> %s, SQL %q: filtered=(%q, %v), unfiltered=(%q, %v)", from, to, sql, got, gotErr, want, wantErr)
+	}
+}
+
+func TestPrefilterEquivalence(t *testing.T) {
+	dialects := prefilterDialects()
+	if testing.Short() {
+		dialects = []keywords.SQLDialect{keywords.DialectPostgreSQL, keywords.DialectMySQL, keywords.DialectSQLite}
+	}
+	fixed := []string{
+		"CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, flag TINYINT(1))",
+		"SELECT a = 1 || b = 2 FROM t", "SELECT a || b FROM t", "SELECT a OR b FROM t",
+		"SELECT 'a\\nb'", "SELECT \"x\"", "SELECT $$a\\b$$", "SELECT $tag$a\\b$tag$",
+		"SELECT ‘a’", "SELECT «a»", "SELECT E'a\\nb'", "SELECT N'a'", "SELECT X'41'", "SELECT B'01'",
+		"SELECT q'[a]'", "SELECT _utf8mb4'a'", "SELECT 'a\x00b'",
+		`CREATE TABLE t (v "custom")`, "CREATE TABLE t (v `custom`)", "CREATE TABLE t (v [custom])", "CREATE TABLE t (v INT[])",
+		"SELECT 'a\x00b'; SELECT a ^ b", "SELECT a ^ b; SELECT 'a\x00b'",
+		"SELECT emp# FROM t", "SELECT 1 -- ' || [\n", "SELECT 1 /* $ || [ */", "SELECT 1; SELECT 'x'", "SELECT (((1)))",
+	}
+	for _, from := range dialects {
+		for _, to := range dialects {
+			t.Run(string(from)+"_"+string(to), func(t *testing.T) {
+				for _, sql := range fixed {
+					checkPrefilterEquivalent(t, sql, from, to)
+				}
+			})
+		}
+	}
+	files := 0
+	err := filepath.WalkDir("../../testdata/realworld", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() || filepath.Ext(path) != ".sql" {
+			return nil
+		}
+		files++
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		// Deliberately split exactly on semicolons, including chunks inside quoted
+		// strings: malformed fragments also pin equality of parse errors.
+		statements := strings.Split(string(data), ";")
+		if testing.Short() && len(statements) > 2 {
+			statements = statements[:2]
+		}
+		for _, sql := range statements {
+			if strings.TrimSpace(sql) == "" {
+				continue
+			}
+			for _, from := range dialects {
+				for _, to := range dialects {
+					checkPrefilterEquivalent(t, sql, from, to)
+				}
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if files == 0 {
+		t.Fatal("realworld corpus contained no SQL files")
+	}
+}
+
+func TestScanSourceStringOpeners(t *testing.T) {
+	cases := []struct {
+		literal string
+		dialect keywords.SQLDialect
+		flags   sourceFeatures
+	}{
+		{"'abc'", keywords.DialectPostgreSQL, sourceFeatures{quote: true}},
+		{`"abc"`, keywords.DialectMySQL, sourceFeatures{quote: true, typeDelim: true}},
+		{"$$abc$$", keywords.DialectPostgreSQL, sourceFeatures{quote: true}},
+		{"$tag$abc$tag$", keywords.DialectPostgreSQL, sourceFeatures{quote: true}},
+		{"‘abc’", keywords.DialectPostgreSQL, sourceFeatures{nonASCII: true}},
+		{"«abc»", keywords.DialectPostgreSQL, sourceFeatures{nonASCII: true}},
+		{"E'abc'", keywords.DialectPostgreSQL, sourceFeatures{quote: true}},
+		{"N'abc'", keywords.DialectSQLServer, sourceFeatures{quote: true}},
+		{"X'41'", keywords.DialectMySQL, sourceFeatures{quote: true}},
+		{"B'01'", keywords.DialectPostgreSQL, sourceFeatures{quote: true}},
+		{"q'[abc]'", keywords.DialectOracle, sourceFeatures{quote: true, typeDelim: true}},
+		{"_utf8mb4'abc'", keywords.DialectMySQL, sourceFeatures{quote: true}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.literal, func(t *testing.T) {
+			sql := "SELECT " + tc.literal
+			if got := scanSource(sql); got != tc.flags {
+				t.Fatalf("scanSource=%+v, want %+v", got, tc.flags)
+			}
+			tree, err := parser.ParseWithDialect(sql, tc.dialect)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer ast.ReleaseAST(tree)
+			found := false
+			ast.Inspect(tree, func(n ast.Node) bool {
+				if lit, ok := n.(*ast.LiteralValue); ok && lit.Type == "string" {
+					found = true
+				}
+				return true
+			})
+			if !found {
+				// nextToken routes MySQL double quotes to readQuotedIdentifier.
+				// Pin that existing parser behavior as well as the conservative
+				// quote gate; changing its semantics is outside this optimization.
+				if tc.literal != `"abc"` {
+					t.Fatal("opener did not produce a string literal")
+				}
+				identifier := false
+				ast.Inspect(tree, func(n ast.Node) bool {
+					if _, ok := n.(*ast.Identifier); ok {
+						identifier = true
+					}
+					return true
+				})
+				if !identifier {
+					t.Fatal("MySQL double quotes produced neither identifier nor literal")
+				}
+			}
+			flags := scanSource(sql)
+			if !flags.quote && !flags.nonASCII {
+				t.Fatal("string literal would skip retargeting")
+			}
+		})
+	}
+}
+
+func TestScanSourceTypeDelimiters(t *testing.T) {
+	for _, tc := range []struct {
+		typ     string
+		dialect keywords.SQLDialect
+	}{
+		{`"t"`, keywords.DialectPostgreSQL}, {"`t`", keywords.DialectMySQL}, {"[t]", keywords.DialectSQLServer}, {"INT[]", keywords.DialectPostgreSQL},
+	} {
+		t.Run(tc.typ, func(t *testing.T) {
+			sql := "CREATE TABLE tbl (v " + tc.typ + ")"
+			if !scanSource(sql).typeDelim {
+				t.Fatal("quoted or array type would skip restyling")
+			}
+			tree, err := parser.ParseWithDialect(sql, tc.dialect)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer ast.ReleaseAST(tree)
+		})
+	}
+}
+
+func TestPrefilterPipesTokenAndAST(t *testing.T) {
+	tk := tokenizer.GetTokenizer()
+	defer tokenizer.PutTokenizer(tk)
+	for _, from := range prefilterDialects() {
+		tk.SetDialect(from)
+		for _, op := range []string{"||", "OR", "|"} {
+			sql := "SELECT a " + op + " b FROM t"
+			toks, err := tk.TokenizeString(sql)
+			if err != nil {
+				t.Fatal(err)
+			}
+			concatTokens := 0
+			for _, tok := range toks {
+				if tok.Token.Type == models.TokenTypeStringConcat {
+					concatTokens++
+					if tok.Token.Value != "||" {
+						t.Fatalf("concat token from %q", tok.Token.Value)
+					}
+				}
+			}
+			if (concatTokens == 1) != (op == "||") {
+				t.Fatalf("%s %q: %d StringConcat tokens", from, op, concatTokens)
+			}
+			tree, err := parser.ParseWithDialect(sql, from)
+			if err != nil {
+				t.Fatal(err)
+			}
+			matched := false
+			ast.Inspect(tree, func(n ast.Node) bool {
+				if bin, ok := n.(*ast.BinaryExpression); ok && (bin.PipesOr || bin.Operator == "||") {
+					matched = true
+				}
+				return true
+			})
+			ast.ReleaseAST(tree)
+			if matched != (op == "||") {
+				t.Fatalf("%s %q: PipesOr/concat = %v", from, op, matched)
+			}
+			if matched && !scanSource(sql).pipe {
+				t.Fatal("pipe rewrite would be skipped")
+			}
+		}
+	}
+}
+
+func TestPrefilterMustRunAndSkip(t *testing.T) {
+	cases := []struct {
+		sql                     string
+		from, to                keywords.SQLDialect
+		contains, errorContains string
+	}{
+		{"SELECT a = 1 || b = 2 FROM t", keywords.DialectMySQL, keywords.DialectPostgreSQL, " OR ", ""},
+		{"SELECT a || b FROM t", keywords.DialectPostgreSQL, keywords.DialectMySQL, "CONCAT(", ""},
+		{`SELECT 'a\0b'`, keywords.DialectMySQL, keywords.DialectSQLite, "", "control character U+0000"},
+		{`CREATE TABLE t (v "custom")`, keywords.DialectPostgreSQL, keywords.DialectSQLServer, "[custom]", ""},
+	}
+	for _, tc := range cases {
+		checkPrefilterEquivalent(t, tc.sql, tc.from, tc.to)
+		got, err := Transpile(tc.sql, tc.from, tc.to)
+		if tc.errorContains != "" {
+			if err == nil || !strings.Contains(err.Error(), tc.errorContains) {
+				t.Fatalf("%q: got %q, %v", tc.sql, got, err)
+			}
+		} else if err != nil || !strings.Contains(got, tc.contains) {
+			t.Fatalf("%q: got %q, %v; want %q", tc.sql, got, err, tc.contains)
+		}
+	}
+	for _, sql := range []string{`SELECT 'a\0b'; SELECT a ^ b`, `SELECT a ^ b; SELECT 'a\0b'`} {
+		checkPrefilterEquivalent(t, sql, keywords.DialectMySQL, keywords.DialectSQLite)
+		_, err := Transpile(sql, keywords.DialectMySQL, keywords.DialectSQLite)
+		if err == nil || !strings.Contains(err.Error(), "bitwise XOR operator") {
+			t.Fatalf("operator pass must fail before literal pass: %v", err)
+		}
+	}
+	const create = "CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, flag TINYINT(1))"
+	if got := scanSource(create); got != (sourceFeatures{}) {
+		t.Fatalf("benchmark input should skip all three optional passes: %+v", got)
+	}
+	checkPrefilterEquivalent(t, create, keywords.DialectMySQL, keywords.DialectPostgreSQL)
+}
+
+func TestRulesForFreshSliceAndBoundedCache(t *testing.T) {
+	from, to := keywords.DialectMySQL, keywords.DialectPostgreSQL
+	const sql = "SELECT a = 1 || b = 2 FROM t"
+	want, err := Transpile(sql, from, to)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rs := RulesFor(from, to)
+	if len(rs) == 0 {
+		t.Fatal("expected registered rules")
+	}
+	rs[0] = func(ast.Statement) error { return fmt.Errorf("mutated caller slice") }
+	got, err := Transpile(sql, from, to)
+	if err != nil || got != want {
+		t.Fatalf("caller mutation affected Transpile: %q, %v", got, err)
+	}
+	if len(rulesCache) != 9*9*2 {
+		t.Fatalf("cache size = %d, want 162", len(rulesCache))
+	}
+	for i := 0; i < 32; i++ {
+		unknown := keywords.SQLDialect(fmt.Sprintf("unknown-%d", i))
+		for _, pipes := range []bool{false, true} {
+			for _, pair := range [][2]keywords.SQLDialect{{unknown, to}, {from, unknown}, {unknown, unknown}} {
+				cached := rulesForSource(pair[0], pair[1], pipes)
+				built := buildRules(pair[0], pair[1], pipes)
+				if len(cached) != len(built) {
+					t.Fatalf("unknown fallback length = %d, want %d", len(cached), len(built))
+				}
+				// Execute both independently: row-limit closures must keep per-call state.
+				a, e1 := transpile("SELECT a FROM t LIMIT 2", pair[0], pair[1], true)
+				b, e2 := transpile("SELECT a FROM t LIMIT 2", pair[0], pair[1], false)
+				if a != b || fmt.Sprint(e1) != fmt.Sprint(e2) {
+					t.Fatalf("unknown fallback differs: %q %v vs %q %v", a, e1, b, e2)
+				}
+			}
+		}
+	}
+	if len(rulesCache) != 162 {
+		t.Fatalf("unknown dialects grew cache to %d", len(rulesCache))
+	}
+	for _, from := range prefilterDialects() {
+		for _, to := range prefilterDialects() {
+			for _, pipes := range []bool{false, true} {
+				got, ok := rulesCache[rulesKey{from, to, pipes}]
+				if !ok {
+					t.Fatalf("missing cache pair %s/%s/%v", from, to, pipes)
+				}
+				want := buildRules(from, to, pipes)
+				if len(got) != len(want) {
+					t.Fatal("cached rule list differs")
+				}
+				for i := range got {
+					if reflect.ValueOf(got[i]).Pointer() != reflect.ValueOf(want[i]).Pointer() {
+						t.Fatal("cached rule order differs")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestPrefilterParallelTranspile(t *testing.T) {
+	for _, from := range prefilterDialects() {
+		for _, to := range prefilterDialects() {
+			t.Run(string(from)+"_"+string(to), func(t *testing.T) {
+				t.Parallel()
+				for i := 0; i < 8; i++ {
+					for _, sql := range []string{"SELECT a || b FROM t LIMIT 2", "SELECT 'a\\b' FROM t", "CREATE TABLE t (a INT)"} {
+						checkPrefilterEquivalent(t, sql, from, to)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/pkg/transpiler/quoting.go b/pkg/transpiler/quoting.go
index 499da957e..e635b858c 100644
--- a/pkg/transpiler/quoting.go
+++ b/pkg/transpiler/quoting.go
@@ -38,10 +38,12 @@ func identifierDelimiter(d keywords.SQLDialect) rune {
 // the target dialect's (see identifierDelimiter), so a MySQL `my col` is not
 // carried into PostgreSQL output where backticks are invalid. Oracle bare
 // names with '#' (emp#) stay bare only when the target is Oracle too.
-func requoteIdentifiers(stmt ast.Statement, from, to keywords.SQLDialect) {
+func requoteIdentifiers(stmt ast.Statement, from, to keywords.SQLDialect, typeDelims bool) {
 	if from == to {
 		return
 	}
 	ast.SetNameQuoteStyle(stmt, identifierDelimiter(to), to == keywords.DialectOracle)
-	ast.RestyleDataTypes(stmt, identifierDelimiter(to))
+	if typeDelims {
+		ast.RestyleDataTypes(stmt, identifierDelimiter(to))
+	}
 }
diff --git a/pkg/transpiler/rules/pg_concat.go b/pkg/transpiler/rules/pg_concat.go
index 8f42f257c..aae51a282 100644
--- a/pkg/transpiler/rules/pg_concat.go
+++ b/pkg/transpiler/rules/pg_concat.go
@@ -17,6 +17,7 @@ package rules
 import (
 	"reflect"
 
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
 )
 
@@ -36,7 +37,8 @@ func PgConcatToMySQLConcat(stmt ast.Statement) error {
 	if stmt == nil || !containsConcat(stmt) {
 		return nil
 	}
-	rewriteConcatIn(reflect.ValueOf(stmt), make(map[uintptr]struct{}))
+	v := reflect.ValueOf(stmt)
+	rewriteConcatIn(v, reflplan.Of(v.Type()), make(map[uintptr]struct{}))
 	return nil
 }
 
@@ -75,7 +77,11 @@ var funcCallType = reflect.TypeOf((*ast.FunctionCall)(nil))
 // call. Expressions are stored in interface-typed fields, slices and value
 // structs (e.g. JoinClause), which ast.Walk cannot replace in place, hence
 // reflection. seen guards against revisiting shared pointers.
-func rewriteConcatIn(v reflect.Value, seen map[uintptr]struct{}) {
+// Pruned interface-free pointers no longer enter the address-only seen set.
+// This can only visit more, never fewer; output could differ from an unpruned
+// walk only if a pruned value aliased a rewrite node's address, which the
+// parser does not produce. Reachable slot order is unchanged.
+func rewriteConcatIn(v reflect.Value, p *reflplan.Plan, seen map[uintptr]struct{}) {
 	switch v.Kind() {
 	case reflect.Pointer:
 		if v.IsNil() {
@@ -86,29 +92,29 @@ func rewriteConcatIn(v reflect.Value, seen map[uintptr]struct{}) {
 			return
 		}
 		seen[ptr] = struct{}{}
-		rewriteConcatIn(v.Elem(), seen)
+		rewriteConcatIn(v.Elem(), p.Elem, seen)
 	case reflect.Interface:
 		if !v.IsNil() {
-			rewriteConcatIn(v.Elem(), seen)
+			e := v.Elem()
+			rewriteConcatIn(e, reflplan.Of(e.Type()), seen)
 		}
 	case reflect.Struct:
-		t := v.Type()
-		for i := 0; i < v.NumField(); i++ {
-			if !t.Field(i).IsExported() {
-				continue
-			}
-			rewriteConcatSlot(v.Field(i), seen)
+		for _, f := range p.Fields {
+			rewriteConcatSlot(v.Field(f.Index), f.Plan, seen)
 		}
 	case reflect.Slice, reflect.Array:
+		if !p.Elem.Reach {
+			return
+		}
 		for i := 0; i < v.Len(); i++ {
-			rewriteConcatSlot(v.Index(i), seen)
+			rewriteConcatSlot(v.Index(i), p.Elem, seen)
 		}
 	}
 }
 
 // rewriteConcatSlot replaces slot with CONCAT(...) when it is a settable
 // interface slot holding a concatenation; otherwise it descends into it.
-func rewriteConcatSlot(slot reflect.Value, seen map[uintptr]struct{}) {
+func rewriteConcatSlot(slot reflect.Value, p *reflplan.Plan, seen map[uintptr]struct{}) {
 	if slot.Kind() == reflect.Interface && !slot.IsNil() && slot.CanSet() &&
 		funcCallType.AssignableTo(slot.Type()) {
 		if e, ok := slot.Interface().(ast.Expression); ok {
@@ -118,15 +124,17 @@ func rewriteConcatSlot(slot reflect.Value, seen map[uintptr]struct{}) {
 			}
 		}
 	}
-	rewriteConcatIn(slot, seen)
+	rewriteConcatIn(slot, p, seen)
 }
 
+var expressionPlan = reflplan.Of(reflect.TypeOf((*ast.Expression)(nil)).Elem())
+
 // buildConcatCall flattens a || chain into CONCAT(args...), rewriting any
 // concatenation nested inside the operands as well.
 func buildConcatCall(bin *ast.BinaryExpression, seen map[uintptr]struct{}) *ast.FunctionCall {
 	args := flattenConcat(bin, nil)
 	for i := range args {
-		rewriteConcatSlot(reflect.ValueOf(&args[i]).Elem(), seen)
+		rewriteConcatSlot(reflect.ValueOf(&args[i]).Elem(), expressionPlan, seen)
 	}
 	return &ast.FunctionCall{Name: "CONCAT", Arguments: args}
 }
diff --git a/pkg/transpiler/rules/pipes_or.go b/pkg/transpiler/rules/pipes_or.go
index 99635fb88..8c54e3826 100644
--- a/pkg/transpiler/rules/pipes_or.go
+++ b/pkg/transpiler/rules/pipes_or.go
@@ -17,6 +17,7 @@ package rules
 import (
 	"reflect"
 
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
 )
 
@@ -33,7 +34,8 @@ func PipesOrToKeywordOr(stmt ast.Statement) error {
 	if stmt == nil {
 		return nil
 	}
-	clearPipesOr(reflect.ValueOf(stmt), make(map[uintptr]struct{}))
+	v := reflect.ValueOf(stmt)
+	clearPipesOr(v, reflplan.Of(v.Type()), make(map[uintptr]struct{}))
 	return nil
 }
 
@@ -42,8 +44,13 @@ var binaryExprType = reflect.TypeOf(ast.BinaryExpression{})
 // clearPipesOr walks every exported field reachable from v and clears
 // PipesOr on each BinaryExpression. Reflection reaches expressions stored in
 // value structs and slices that ast.Walk does not visit; seen guards against
-// revisiting shared pointers.
-func clearPipesOr(v reflect.Value, seen map[uintptr]struct{}) {
+// revisiting shared pointers. Parts whose type cannot hold an interface are
+// skipped (reflplan): a BinaryExpression is only ever reached through one.
+// Pruned interface-free pointers no longer enter the address-only seen set.
+// This can only visit more, never fewer; output could differ from an unpruned
+// walk only if a pruned value aliased a rewrite node's address, which the
+// parser does not produce. Reachable slot order is unchanged.
+func clearPipesOr(v reflect.Value, p *reflplan.Plan, seen map[uintptr]struct{}) {
 	switch v.Kind() {
 	case reflect.Pointer:
 		if v.IsNil() {
@@ -54,26 +61,27 @@ func clearPipesOr(v reflect.Value, seen map[uintptr]struct{}) {
 			return
 		}
 		seen[ptr] = struct{}{}
-		clearPipesOr(v.Elem(), seen)
+		clearPipesOr(v.Elem(), p.Elem, seen)
 	case reflect.Interface:
 		if !v.IsNil() {
-			clearPipesOr(v.Elem(), seen)
+			e := v.Elem()
+			clearPipesOr(e, reflplan.Of(e.Type()), seen)
 		}
 	case reflect.Struct:
-		if v.Type() == binaryExprType && v.CanAddr() {
+		if p.Type == binaryExprType && v.CanAddr() {
 			if bin, ok := v.Addr().Interface().(*ast.BinaryExpression); ok {
 				bin.PipesOr = false
 			}
 		}
-		t := v.Type()
-		for i := 0; i < v.NumField(); i++ {
-			if t.Field(i).IsExported() {
-				clearPipesOr(v.Field(i), seen)
-			}
+		for _, f := range p.Fields {
+			clearPipesOr(v.Field(f.Index), f.Plan, seen)
 		}
 	case reflect.Slice, reflect.Array:
+		if !p.Elem.Reach {
+			return
+		}
 		for i := 0; i < v.Len(); i++ {
-			clearPipesOr(v.Index(i), seen)
+			clearPipesOr(v.Index(i), p.Elem, seen)
 		}
 	}
 }
diff --git a/pkg/transpiler/string_literals.go b/pkg/transpiler/string_literals.go
index b634b1711..04741852e 100644
--- a/pkg/transpiler/string_literals.go
+++ b/pkg/transpiler/string_literals.go
@@ -19,6 +19,7 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/dialect"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
@@ -131,34 +132,43 @@ type seenPtr struct {
 // keep the source escaping. seen guards against shared or cyclic pointers.
 // An explicit stack preserves pre-order without consuming the goroutine stack.
 func forEachLiteral(v reflect.Value, seen map[seenPtr]bool, f func(*ast.LiteralValue)) {
-	var small [64]reflect.Value
-	stack := append(small[:0], v)
+	type item struct {
+		v reflect.Value
+		p *reflplan.Plan
+	}
+	if !v.IsValid() {
+		return
+	}
+	var small [64]item
+	stack := append(small[:0], item{v, reflplan.Of(v.Type())})
 	for len(stack) > 0 {
-		v = stack[len(stack)-1]
+		it := stack[len(stack)-1]
+		v, p := it.v, it.p
 		stack = stack[:len(stack)-1]
 		switch v.Kind() {
 		case reflect.Interface:
 			if !v.IsNil() {
-				stack = append(stack, v.Elem())
+				e := v.Elem()
+				stack = append(stack, item{e, reflplan.Of(e.Type())})
 			}
 		case reflect.Pointer:
 			if v.IsNil() {
 				continue
 			}
-			key := seenPtr{v.Type(), v.Pointer()}
+			key := seenPtr{p.Type, v.Pointer()}
 			if seen[key] {
 				continue
 			}
 			seen[key] = true
-			if v.Elem().Type() == literalType {
+			if p.Elem.Type == literalType {
 				if lit, ok := v.Interface().(*ast.LiteralValue); ok {
 					f(lit)
 				}
 				continue
 			}
-			stack = append(stack, v.Elem())
+			stack = append(stack, item{v.Elem(), p.Elem})
 		case reflect.Struct:
-			if v.Type() == literalType {
+			if p.Type == literalType {
 				if v.CanAddr() {
 					if lit, ok := v.Addr().Interface().(*ast.LiteralValue); ok {
 						f(lit)
@@ -166,21 +176,25 @@ func forEachLiteral(v reflect.Value, seen map[seenPtr]bool, f func(*ast.LiteralV
 				}
 				continue
 			}
-			t := v.Type()
-			for i := v.NumField() - 1; i >= 0; i-- {
-				if t.Field(i).IsExported() {
-					stack = append(stack, v.Field(i))
-				}
+			for i := len(p.Fields) - 1; i >= 0; i-- {
+				fp := p.Fields[i]
+				stack = append(stack, item{v.Field(fp.Index), fp.Plan})
 			}
 		case reflect.Slice, reflect.Array:
+			if !p.Elem.Reach {
+				continue
+			}
 			for i := v.Len() - 1; i >= 0; i-- {
-				stack = append(stack, v.Index(i))
+				stack = append(stack, item{v.Index(i), p.Elem})
 			}
 		case reflect.Map:
+			if !p.Elem.Reach {
+				continue
+			}
 			iter := v.MapRange()
 			start := len(stack)
 			for iter.Next() {
-				stack = append(stack, iter.Value())
+				stack = append(stack, item{iter.Value(), p.Elem})
 			}
 			// Preserve this iterator's order with a LIFO stack.
 			for i, j := start, len(stack)-1; i < j; i, j = i+1, j-1 {
diff --git a/pkg/transpiler/transpiler.go b/pkg/transpiler/transpiler.go
index 14d6245d0..ee1ce61fc 100644
--- a/pkg/transpiler/transpiler.go
+++ b/pkg/transpiler/transpiler.go
@@ -60,6 +60,10 @@ type RewriteRule func(stmt ast.Statement) error
 // object constants) are rewritten for the target or return an error; see
 // retargetOperators.
 func Transpile(sql string, from, to keywords.SQLDialect) (string, error) {
+	return transpile(sql, from, to, true)
+}
+
+func transpile(sql string, from, to keywords.SQLDialect, prefilter bool) (string, error) {
 	// Use ParseWithDialect so the tokenizer and parser understand dialect-
 	// specific syntax (e.g. MySQL backtick identifiers, PG ILIKE, etc.).
 	tree, err := parser.ParseWithDialect(sql, from)
@@ -77,8 +81,13 @@ func Transpile(sql string, from, to keywords.SQLDialect) (string, error) {
 		}
 	}
 
-	// Apply rules for this dialect pair.
-	rules := rulesFor(from, to)
+	// Prefilters are superset tests on source bytes: false positives only cost
+	// a walk; false negatives would change output or error order.
+	src := scanSource(sql)
+	// The tokenizer emits TokenTypeStringConcat only for two adjacent |, and
+	// the parser's OR and concatenation parsing are the only producers of
+	// PipesOr and ||; no rewrite rule creates either.
+	rules := rulesForSource(from, to, !prefilter || src.pipe)
 	for _, stmt := range tree.Statements {
 		for _, rule := range rules {
 			if err := rule(stmt); err != nil {
@@ -88,14 +97,23 @@ func Transpile(sql string, from, to keywords.SQLDialect) (string, error) {
 		if err := retargetOperators(stmt, from, to); err != nil {
 			return "", fmt.Errorf("rewrite: %w", err)
 		}
-		requoteIdentifiers(stmt, from, to)
+		// requoteDataType (ast/data_type_quotes.go) is the identity without
+		// ", ` or [. The parser inserts these only from quoted type tokens
+		// (typeNameTokenSQL) or [ tokens; rules only assign bare type names.
+		// SetNameQuoteStyle still runs: names can have content delimiters.
+		requoteIdentifiers(stmt, from, to, !prefilter || src.typeDelim || src.nonASCII)
 	}
 
 	// Re-render string literals for the target dialect (escaping and
 	// introducers); see retargetStringLiterals.
-	for _, stmt := range tree.Statements {
-		if err := retargetStringLiterals(stmt, to); err != nil {
-			return "", fmt.Errorf("rewrite: %w", err)
+	// Type "string" is set only by parser/string_literal.go's
+	// newStringLiteral; all 11 callers consume string tokens. Their openers
+	// contain ', " or $, or a non-ASCII byte (Unicode quote delimiters).
+	if !prefilter || src.quote || src.nonASCII {
+		for _, stmt := range tree.Statements {
+			if err := retargetStringLiterals(stmt, to); err != nil {
+				return "", fmt.Errorf("rewrite: %w", err)
+			}
 		}
 	}
 
@@ -110,3 +128,24 @@ func Transpile(sql string, from, to keywords.SQLDialect) (string, error) {
 	}
 	return out, nil
 }
+
+type sourceFeatures struct{ pipe, quote, nonASCII, typeDelim bool }
+
+func scanSource(sql string) sourceFeatures {
+	var f sourceFeatures
+	for i := 0; i < len(sql); i++ {
+		switch c := sql[i]; {
+		case c >= 0x80:
+			f.nonASCII = true
+		case c == '|':
+			f.pipe = true
+		case c == '\'' || c == '$':
+			f.quote = true
+		case c == '"':
+			f.quote, f.typeDelim = true, true
+		case c == '`' || c == '[':
+			f.typeDelim = true
+		}
+	}
+	return f
+}
diff --git a/pkg/transpiler/transpiler_test.go b/pkg/transpiler/transpiler_test.go
index 7149dbbb1..8425d1e13 100644
--- a/pkg/transpiler/transpiler_test.go
+++ b/pkg/transpiler/transpiler_test.go
@@ -154,3 +154,39 @@ func TestTranspile_NestedParenthesizedWith(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkTranspile_SelectOps(b *testing.B) {
+	const sql = "SELECT u.id, u.name || 'x', COUNT(*) AS c, a ^ b, CASE WHEN u.age > 18 AND u.flag = 1 THEN 'adult' ELSE 'minor' END FROM users u JOIN orders o ON o.uid = u.id AND o.total > 10 WHERE u.status IN ('a','b') OR (u.score * 2 + 1) >= 5 GROUP BY u.id, u.name HAVING COUNT(*) > 1 ORDER BY c DESC LIMIT 10"
+	for _, p := range []struct {
+		name     string
+		from, to keywords.SQLDialect
+	}{
+		{"mysql2pg", keywords.DialectMySQL, keywords.DialectPostgreSQL},
+		{"pg2mysql", keywords.DialectPostgreSQL, keywords.DialectMySQL},
+	} {
+		b.Run(p.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				if _, err := transpiler.Transpile(sql, p.from, p.to); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+// A large tree must not leave stale seen pointers or AST references in scratch
+// retained for the next, small call.
+func TestTranspileDeepChainFollowedBySmall(t *testing.T) {
+	if testing.Short() || raceEnabled {
+		t.Skip("near-ceiling chain skipped under -short and -race")
+	}
+	checkDeepChain(t, "OR", 490000, keywords.DialectPostgreSQL, keywords.DialectMySQL)
+	got, err := transpiler.Transpile("SELECT a || b FROM t", keywords.DialectPostgreSQL, keywords.DialectMySQL)
+	if err != nil {
+		t.Fatalf("small transpile after large tree: %v", err)
+	}
+	if want := "SELECT CONCAT(a, b) FROM t"; got != want {
+		t.Fatalf("small transpile after large tree = %q, want %q", got, want)
+	}
+}
diff --git a/pkg/transpiler/walk_coverage_test.go b/pkg/transpiler/walk_coverage_test.go
new file mode 100644
index 000000000..b43bc9922
--- /dev/null
+++ b/pkg/transpiler/walk_coverage_test.go
@@ -0,0 +1,206 @@
+// Copyright 2026 GoSQLX Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package transpiler_test
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
+	"github.com/ajitpratap0/GoSQLX/pkg/internal/reflplan"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
+)
+
+type walkCoverageKey struct {
+	address uintptr
+	typ     reflect.Type
+}
+
+type walkCoverageSet map[walkCoverageKey]struct{}
+
+// recordWalkCoverage records interface slots (including scalar dynamic values)
+// and the pointer rewrite sites that do not require an interface slot. Addressable
+// interface slots identify scalar values; pointer values identify their pointees.
+func recordWalkCoverage(v reflect.Value, found walkCoverageSet) {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		dynamic := v.Elem()
+		var address uintptr
+		if dynamic.Kind() == reflect.Pointer {
+			address = dynamic.Pointer()
+		} else if v.CanAddr() {
+			address = v.Addr().Pointer()
+		}
+		found[walkCoverageKey{address, dynamic.Type()}] = struct{}{}
+	}
+	if v.Kind() == reflect.Pointer && !v.IsNil() &&
+		(v.Type() == reflect.TypeFor[*ast.LiteralValue]() || v.Type() == reflect.TypeFor[*ast.BinaryExpression]()) {
+		found[walkCoverageKey{v.Pointer(), v.Type()}] = struct{}{}
+	}
+}
+
+// naiveWalkCoverage deliberately examines every exported field and every
+// container element without consulting reflplan or any static reachability test.
+func naiveWalkCoverage(root reflect.Value) walkCoverageSet {
+	found := make(walkCoverageSet)
+	seen := make(map[walkCoverageKey]bool)
+	stack := []reflect.Value{root}
+	for len(stack) > 0 {
+		v := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		if !v.IsValid() {
+			continue
+		}
+		recordWalkCoverage(v, found)
+		switch v.Kind() {
+		case reflect.Pointer:
+			if v.IsNil() {
+				continue
+			}
+			key := walkCoverageKey{v.Pointer(), v.Type()}
+			if seen[key] {
+				continue
+			}
+			seen[key] = true
+			stack = append(stack, v.Elem())
+		case reflect.Interface:
+			if !v.IsNil() {
+				stack = append(stack, v.Elem())
+			}
+		case reflect.Struct:
+			for i := 0; i < v.NumField(); i++ {
+				if v.Type().Field(i).IsExported() {
+					stack = append(stack, v.Field(i))
+				}
+			}
+		case reflect.Slice, reflect.Array:
+			for i := 0; i < v.Len(); i++ {
+				stack = append(stack, v.Index(i))
+			}
+		case reflect.Map:
+			iter := v.MapRange()
+			for iter.Next() {
+				stack = append(stack, iter.Value())
+			}
+		}
+	}
+	return found
+}
+
+func plannedWalkCoverage(root reflect.Value) walkCoverageSet {
+	type frame struct {
+		v reflect.Value
+		p *reflplan.Plan
+	}
+	found := make(walkCoverageSet)
+	seen := make(map[walkCoverageKey]bool)
+	stack := []frame{{root, reflplan.Of(root.Type())}}
+	for len(stack) > 0 {
+		f := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		v, p := f.v, f.p
+		if !v.IsValid() {
+			continue
+		}
+		recordWalkCoverage(v, found)
+		switch v.Kind() {
+		case reflect.Pointer:
+			if v.IsNil() || !p.Elem.Reach {
+				continue
+			}
+			key := walkCoverageKey{v.Pointer(), v.Type()}
+			if seen[key] {
+				continue
+			}
+			seen[key] = true
+			stack = append(stack, frame{v.Elem(), p.Elem})
+		case reflect.Interface:
+			if !v.IsNil() {
+				elem := v.Elem()
+				stack = append(stack, frame{elem, reflplan.Of(elem.Type())})
+			}
+		case reflect.Struct:
+			for _, field := range p.Fields {
+				stack = append(stack, frame{v.Field(field.Index), field.Plan})
+			}
+		case reflect.Slice, reflect.Array:
+			if p.Elem.Reach {
+				for i := 0; i < v.Len(); i++ {
+					stack = append(stack, frame{v.Index(i), p.Elem})
+				}
+			}
+		case reflect.Map:
+			if p.Elem.Reach {
+				iter := v.MapRange()
+				for iter.Next() {
+					stack = append(stack, frame{iter.Value(), p.Elem})
+				}
+			}
+		}
+	}
+	return found
+}
+
+func TestReflectionPlanRealWorldWalkCoverage(t *testing.T) {
+	root := filepath.Join("..", "..", "testdata", "realworld")
+	parsed, skipped := 0, 0
+	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() || filepath.Ext(path) != ".sql" {
+			return nil
+		}
+		rel, err := filepath.Rel(root, path)
+		if err != nil {
+			return err
+		}
+		dialect := strings.Split(filepath.ToSlash(rel), "/")[0]
+		if !keywords.IsValidDialect(dialect) {
+			return fmt.Errorf("invalid corpus dialect %q", dialect)
+		}
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		for i, sql := range gosqlx.SplitStatements(string(data), dialect) {
+			tree, err := parser.ParseWithDialect(sql, keywords.SQLDialect(dialect))
+			if err != nil {
+				// The corpus intentionally includes known parser failures.
+				skipped++
+				continue
+			}
+			func() {
+				defer ast.ReleaseAST(tree)
+				for j, stmt := range tree.Statements {
+					parsed++
+					value := reflect.ValueOf(stmt)
+					want, got := naiveWalkCoverage(value), plannedWalkCoverage(value)
+					if !reflect.DeepEqual(got, want) {
+						t.Errorf("%s#%d statement %d: planned coverage has %d sites, naive has %d", rel, i, j, len(got), len(want))
+						for site := range want {
+							if _, ok := got[site]; !ok {
+								t.Errorf("missing rewrite site: %v at %#x", site.typ, site.address)
+							}
+						}
+					}
+				}
+			}()
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if parsed == 0 {
+		t.Fatal("no corpus statements parsed")
+	}
+	t.Logf("compared %d parsed statements; skipped %d known/unparseable inputs", parsed, skipped)
+}