foxhunt/WAVE_14_26_FIX_GUIDE.md

WAVE 14.26: COMPILATION FIX GUIDE

Mission: Fix 19 compilation errors in trading_service Estimated Time: 2-4 hours Approach: Systematic, one file at a time, TDD methodology

---

Error Summary

Total: 19 errors in trading_service Files Affected: 4 files Root Causes: Type system migrations (i32→i64, f64→BigDecimal), SQLX schema drift, API changes

---

Fix Strategy (Priority Order)

Phase 1: SQLX Schema Sync (15 minutes)

Problem: Database schema changed (i32→i64, f64→Decimal) but Rust code not updated

Command:

# Regenerate SQLX metadata
cargo sqlx prepare --workspace --database-url postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# If that fails, try database-first approach
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "\d+ ensemble_predictions"
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "\d+ ml_performance_outcomes"

Expected Outcome: Updated .sqlx/ metadata files with correct types

---

Phase 2: Fix ensemble_audit_logger.rs (4 errors) ⏱️ 30-45 min

File: services/trading_service/src/ensemble_audit_logger.rs

Error 1: Line 527 - SQLX query type mismatch

Error:

error[E0277]: the trait bound `Option<i64>: From<Option<i32>>` is not satisfied
   --> services/trading_service/src/ensemble_audit_logger.rs:527:23

Diagnosis:

• Database column is BIGINT (i64)
• Rust struct expects Option<i32>

Fix:

// BEFORE
struct AuditLogEntry {
    inference_latency_us: Option<i32>,
    // ...
}

// AFTER
struct AuditLogEntry {
    inference_latency_us: Option<i64>,  // Match database BIGINT
    // ...
}

Error 2: Line 527 - SQLX query type mismatch (f64/Decimal)

Error:

error[E0277]: the trait bound `Option<f64>: From<Option<i64>>` is not satisfied

Diagnosis:

• Database column might be NUMERIC or BIGINT
• Rust struct expects Option<f64>

Fix:

// Check database schema first
// psql -c "\d+ ensemble_predictions" | grep signal

// If database is NUMERIC/DECIMAL:
use rust_decimal::Decimal;

struct AuditLogEntry {
    dqn_signal: Option<Decimal>,
    // ...
}

// If database is DOUBLE PRECISION (f64):
struct AuditLogEntry {
    dqn_signal: Option<f64>,
    // ...
}

Error 3: Line 539 - Type mismatch with limit

Error:

error[E0308]: mismatched types
   --> services/trading_service/src/ensemble_audit_logger.rs:539:13
    |
539 |             limit,
    |             ^^^^^ expected `i64`, found `i32`

Fix:

// BEFORE
let limit: i32 = ...;

// AFTER
let limit: i64 = ...;

Error 4: Related parameter types

Fix Strategy:

1. Check all parameter types match database schema
2. Convert i32→i64 where needed
3. Ensure Option types match exactly

Validation:

cargo test -p trading_service --lib ensemble_audit_logger::tests

---

Phase 3: Fix ml_performance_metrics.rs (6 errors) ⏱️ 45-60 min

File: services/trading_service/src/ml_performance_metrics.rs

Error 1: Line 113 - PnL type mismatch

Error:

error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:113:13
    |
113 |             outcome.pnl,

Diagnosis:

• outcome.pnl is BigDecimal or Decimal
• Expected type is f64

Fix:

use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;

// BEFORE
let pnl = outcome.pnl;  // BigDecimal

// AFTER
let pnl = outcome.pnl.to_f64().unwrap_or(0.0);  // Convert to f64

Error 2: Line 115 - prediction_id type mismatch

Error:

error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:115:13
    |
115 |             outcome.prediction_id,

Diagnosis:

• prediction_id might be Option<Uuid> but expected Uuid
• Or type changed from String to Uuid

Fix:

// If Option<Uuid> → Uuid:
let prediction_id = outcome.prediction_id.unwrap_or_else(|| Uuid::nil());

// If String → Uuid:
let prediction_id = Uuid::parse_str(&outcome.prediction_id).unwrap_or_else(|_| Uuid::nil());

Error 3: Line 164 - i64.unwrap_or() not found

Error:

error[E0599]: no method named `unwrap_or` found for type `i64` in the current scope
   --> services/trading_service/src/ml_performance_metrics.rs:164:50
    |
164 |         let correct = result.correct_predictions.unwrap_or(0);

Diagnosis:

• correct_predictions is i64, not Option<i64>
• Database query changed from nullable to NOT NULL

Fix:

// BEFORE
let correct = result.correct_predictions.unwrap_or(0);  // Error: i64 has no unwrap_or

// AFTER (if database column is NOT NULL):
let correct = result.correct_predictions;  // Already i64

// OR (if still nullable in database):
struct QueryResult {
    correct_predictions: Option<i64>,  // Change struct definition
}
let correct = result.correct_predictions.unwrap_or(0);  // Now works

Error 4: Line 205 - avg_pnl type mismatch

Error:

error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:205:48
    |
205 |         let avg_pnl = result.avg_pnl.unwrap_or(0.0);

Diagnosis:

• avg_pnl is Option<Decimal> but code expects Option<f64>

Fix:

use rust_decimal::prelude::ToPrimitive;

// BEFORE
let avg_pnl = result.avg_pnl.unwrap_or(0.0);  // Type mismatch

// AFTER
let avg_pnl = result.avg_pnl
    .and_then(|d| d.to_f64())
    .unwrap_or(0.0);

Errors 5-6: Related type conversions

Fix Strategy:

1. Convert all Decimal to f64 using .to_f64()
2. Handle Option with .and_then(|d| d.to_f64())
3. Check database schema for nullable columns

Validation:

cargo test -p trading_service --lib ml_performance_metrics::tests

---

Phase 4: Fix orders.rs (8 errors) ⏱️ 60-90 min

File: services/trading_service/src/orders.rs

Error Category 1: BigDecimal Arithmetic (3-4 errors)

Error:

error[E0277]: cannot multiply `rust_decimal::Decimal` by `f64`
   --> services/trading_service/src/orders.rs:XXX

Diagnosis:

• Code tries to multiply BigDecimal * f64
• Rust requires same types for arithmetic

Fix Strategy A (Convert to Decimal):

use rust_decimal::Decimal;
use std::str::FromStr;

// BEFORE
let total = price * quantity;  // price: Decimal, quantity: f64

// AFTER
let quantity_decimal = Decimal::from_str(&quantity.to_string()).unwrap();
let total = price * quantity_decimal;

Fix Strategy B (Convert to f64):

use rust_decimal::prelude::ToPrimitive;

// BEFORE
let total = price * quantity;  // price: Decimal, quantity: f64

// AFTER
let price_f64 = price.to_f64().unwrap_or(0.0);
let total = price_f64 * quantity;

Recommendation: Use Strategy B (convert to f64) for performance-critical paths

Error Category 2: DateTime.and_utc() not found (1 error)

Error:

error[E0599]: no method named `and_utc` found for struct `chrono::DateTime` in the current scope
   --> services/trading_service/src/orders.rs:XXX

Diagnosis:

• Chrono API changed
• DateTime<Utc>.and_utc() is redundant (already UTC)

Fix:

use chrono::{DateTime, Utc};

// BEFORE
let timestamp = some_naive_datetime.and_utc();  // Method not found

// AFTER (if NaiveDateTime → DateTime<Utc>):
let timestamp = DateTime::from_naive_utc_and_offset(some_naive_datetime, Utc);

// OR (if already DateTime<Utc>):
let timestamp = some_datetime;  // No conversion needed

Error Category 3: Option to String conversion (2-3 errors)

Error:

error[E0277]: a value of type `Vec<(String, f64)>` cannot be built from an iterator over elements of type `(Option<String>, f64)`
   --> services/trading_service/src/orders.rs:XXX

Diagnosis:

• SQLX query returns Option<String>
• Code expects String (not nullable)

Fix:

// BEFORE
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .collect();  // Error: Option<String> ≠ String

// AFTER (filter out nulls):
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .filter_map(|(opt_str, val)| opt_str.map(|s| (s, val)))
    .collect();

// OR (provide default):
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .map(|(opt_str, val)| (opt_str.unwrap_or_default(), val))
    .collect();

Error Category 4: Miscellaneous type mismatches (2 errors)

Fix Strategy:

1. Read error message carefully
2. Check database schema with \d+ table_name
3. Update Rust struct to match database types
4. Handle Option conversions

Validation:

cargo test -p trading_service --lib orders::tests

---

Phase 5: Fix services/trading.rs (1 error) ⏱️ 15-30 min

File: services/trading_service/src/services/trading.rs

Error: Line 1129 - Match arms incompatible types

Error:

error[E0308]: `match` arms have incompatible types
   --> services/trading_service/src/services/trading.rs:1129:17
    |
1107 |           let predictions = match model_name {
     |  ___________________________-
1108 | |             "DQN" => {...}    // Returns Result<Vec<...>>
1109 | |             "PPO" => {...}    // Returns Vec<...>  ← Type mismatch
     | |_________________________- `match` arms have incompatible types

Diagnosis:

• One match arm returns Result<Vec<T>>
• Another match arm returns Vec<T>
• Rust requires all arms to return same type

Fix:

// BEFORE
let predictions = match model_name {
    "DQN" => self.get_dqn_predictions()?,      // Returns Vec<...>
    "PPO" => self.get_ppo_predictions(),       // Returns Vec<...>
    "MAMBA2" => Err(anyhow!("Not found"))?,    // Returns Result
    _ => vec![],
};

// AFTER (all arms return Result):
let predictions = match model_name {
    "DQN" => self.get_dqn_predictions(),       // Returns Result<Vec<...>>
    "PPO" => self.get_ppo_predictions(),       // Returns Result<Vec<...>>
    "MAMBA2" => Err(anyhow!("Not found")),     // Returns Result
    _ => Ok(vec![]),                           // Returns Result
}?;  // Unwrap outside match

Validation:

cargo test -p trading_service --lib services::trading::tests

---

Verification Steps

After Each Phase

# Compile specific file
cargo build -p trading_service --lib

# Run tests
cargo test -p trading_service --lib

# Check progress
cargo build -p trading_service 2>&1 | grep -c "error"

After All Fixes

# Full workspace compilation
cargo build --workspace --release

# Should output:
# Finished release [optimized] target(s) in X.XXs
# (NO errors)

# Run all tests
cargo test --workspace

# Should show:
# test result: ok. X passed; 0 failed; Y ignored

---

Common Patterns

Pattern 1: Database i32 → i64 Migration

// BEFORE
struct MyStruct {
    count: i32,
    latency_us: Option<i32>,
}

// AFTER
struct MyStruct {
    count: i64,
    latency_us: Option<i64>,
}

Pattern 2: f64 → BigDecimal Migration

use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;

// BEFORE
struct Order {
    price: f64,
    quantity: f64,
}

// AFTER
struct Order {
    price: Decimal,
    quantity: Decimal,
}

// Arithmetic:
let total = price.to_f64().unwrap() * quantity.to_f64().unwrap();

Pattern 3: Option Handling

// Pattern A: Unwrap with default
let value = option_value.unwrap_or(0);

// Pattern B: Convert and unwrap
let value = option_decimal
    .and_then(|d| d.to_f64())
    .unwrap_or(0.0);

// Pattern C: Filter nulls in iterator
let results: Vec<T> = query_results
    .into_iter()
    .filter_map(|opt| opt)
    .collect();

---

Database Schema Reference

Quick Schema Inspection

# Connect to database
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Check table structure
\d+ ensemble_predictions
\d+ ml_performance_outcomes
\d+ orders
\d+ positions

# Check column types
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'ensemble_predictions';

Common Type Mappings

PostgreSQL Type	Rust Type	SQLX Mapping
BIGINT	i64	i64
INTEGER	i32	i32
SMALLINT	i16	i16
NUMERIC/DECIMAL	Decimal	rust_decimal::Decimal
DOUBLE PRECISION	f64	f64
REAL	f32	f32
TEXT/VARCHAR	String	String
BOOLEAN	bool	bool
TIMESTAMP	DateTime	chrono::DateTime
UUID	Uuid	uuid::Uuid

---

TDD Methodology

For Each Fix

1. RED: Verify error exists

   cargo build -p trading_service 2>&1 | grep "error\[E"
   

2. GREEN: Apply fix

   # Edit file
   # Save
   cargo build -p trading_service
   

3. REFACTOR: Run tests

   cargo test -p trading_service --lib
   

4. VALIDATE: Check overall progress

   cargo build --workspace 2>&1 | grep -c "error"
   

---

Success Criteria

Phase Completion

• ✅ Phase 1: SQLX metadata regenerated
• ✅ Phase 2: ensemble_audit_logger.rs compiles (0 errors)
• ✅ Phase 3: ml_performance_metrics.rs compiles (0 errors)
• ✅ Phase 4: orders.rs compiles (0 errors)
• ✅ Phase 5: services/trading.rs compiles (0 errors)

Final Validation

# Zero compilation errors
cargo build --workspace --release
# Expected: "Finished release [optimized] target(s)"

# High test pass rate
cargo test --workspace
# Expected: >1,200 tests passing (95%+)

# Clean status
cargo clippy --workspace -- -D warnings
# Expected: 0 errors, <50 warnings

---

Troubleshooting

If SQLX Metadata Generation Fails

# Check database connection
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "SELECT 1"

# Regenerate with force
cargo sqlx prepare --workspace --database-url postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -- --all-features

# Check .sqlx directory
ls -lh .sqlx/

If Types Still Mismatch After Schema Sync

# Manually inspect database schema
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Compare with Rust struct
rg "struct.*Prediction" services/trading_service/src/

# Update Rust struct to match database exactly

If Tests Fail After Compilation Succeeds

# Run specific test
cargo test -p trading_service --lib test_name -- --nocapture

# Check test logs
cat target/debug/deps/trading_service-*.log

# Debug with prints
# Add println! statements in code
# Recompile and rerun

---

Estimated Timeline

Phase	Task	Time	Cumulative
1	SQLX schema sync	15 min	15 min
2	Fix ensemble_audit_logger.rs	30-45 min	45-60 min
3	Fix ml_performance_metrics.rs	45-60 min	90-120 min
4	Fix orders.rs	60-90 min	150-210 min
5	Fix services/trading.rs	15-30 min	165-240 min
-	Total	2.75-4 hours	-

Target: Complete all fixes in one session (2-4 hours)

---

Next Steps After Compilation Succeeds

1. Run Full Test Suite (1 hour)

   cargo test --workspace
   

2. Measure Coverage (1 hour)

   cargo llvm-cov --workspace --html --output-dir coverage_report
   

3. Execute Smoke Tests (2-3 hours)

   • Start all services
   • Verify health checks
   • Test authentication
   • Test order submission
   • Test ML predictions
   • Test backtesting
   • Test TLI commands

4. Update Production Readiness (1 hour)

   • Document test results
   • Update scorecard
   • Create deployment checklist

Total Time to 95% Production Ready: 7-12 hours

---

End of Guide

Recommendation: Follow phases sequentially, validate after each phase, commit working code frequently.