Zelyra verstehen
im direkten Vergleich.

// 1. schema.prisma + npx prisma generate
model Customer {
  id     Int     @id @default(autoincrement())
  name   String  @db.VarChar(100)
  email  String?
  active Boolean @default(true)
}
// 2. Zod-Validierung muss manuell dupliziert werden:
export const CustomerSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email().optional(),
});
export type CustomerInput = z.infer<typeof CustomerSchema>;

// Diesel: migration.sql + schema.rs + models.rs
#[derive(Queryable, Selectable, Insertable, Serialize, Deserialize)]
#[diesel(table_name = crate::schema::customers)]
pub struct Customer {
    pub id: i32,
    pub name: String,
    pub email: Option<String>,
    pub active: bool,
}
// Validierungs-Crate validator muss zusätzlich implementiert werden:
#[derive(Validate, Deserialize)]
pub struct NewCustomer { ... }

// PHP erlaubt nur primitive Skalare:
function cancelOrder(int $orderId, int $userId): void {
    // ...
}

// ⚠️ Vertauschte Parameter werden klaglos akzeptiert.
// Erst wenn der falsche Kunde oder Auftrag gelöscht wird,
// bemerkt man den Fehler in Produktion!
cancelOrder($currentUserId, $currentOrderId);

// In Rust geht das nur über das Newtype-Pattern:
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct UserId(pub u64);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrderId(pub u64);

fn cancel_order(order: OrderId, user: UserId) { ... }
// Sicher, aber erfordert mühsames Entpacken order.0

$userName = loadUserName($id); // gibt ?string zurück

// Vergessenes if ($userName !== null) führt zum Fatal Crash:
echo strtoupper($userName);

// 💥 Fatal error: Uncaught TypeError:
// strtoupper(): Argument #1 ($string) must be of type string, null given

user, err := loadUser(id)
// Ein vergessenes err != nil oder nil-Pointer-Dereferenzierung:
println(user.Name)

// 💥 panic: runtime error: invalid memory address
// or nil pointer dereference

// Prisma unterstützt komplexe GROUP BY / HAVING nur eingeschränkt:
const aggregations = await prisma.order.groupBy({
  by: ['customerId'],
  _sum: { total: true },
  having: { total: { _sum: { gte: minSpend } } },
});
// Benötigt anschließende zweite Query für Kundendaten:
// -> Gefahr von N+1 Latenz oder komplexen Raw-Queries!

// SQLx in Rust prüft SQL zur Compile-Zeit:
let customers = sqlx::query_as!(
    CustomerSummary,
    r#"SELECT c.id, c.name, SUM(o.total) as total_spent ... "#,
    min_spend
)
.fetch_all(&pool)
.await?;
// Exzellente Sicherheit, erfordert aber laufende DB beim Build!

// Next.js App Router:
export default async function UserPage({ params }: { params: { id: string } }) {
  const user = await db.user.findUnique({ where: { id: Number(params.id) } });
  if (!user) notFound();

  return (
    <div>
      <h1>Profil: {user.name}</h1>
      <p>E-Mail: {user.email}</p>
    </div>
  );
}
// Erfordert Node.js Runtime, JSX-Build-Pipeline und npm packages

async fn show_user(Path(id): Path<i32>) -> Response {
    let user = db::find(id).await;
    Html(format!("<h1>Profil: {}</h1>", user.name)).into_response()
}

let app = Router::new().route("/users/:id", get(show_user));
axum::serve(listener, app).await.unwrap();
// Benötigt Tokio Async-Runtime, Lifetimes und HTML-Escaping Crate