Migrate your database. Keep your code.

1#!/usr/bin/env python3
2
3import eden
4from typing import Dict, Any
5
6def main() -> None:
7    """Initialize Eden client and query database."""
8    client = eden.Client(api_key="your-api-key")
9    
10    try:
11        result: Dict[str, Any] = client.query(
12            "SELECT id, name, email FROM users WHERE active = true"
13        )
14        
15        for user in result.get('data', []):
16            print(f"User: {user['name']} ({user['email']})")
17            
18    except Exception as e:
19        print(f"Error: {e}")
20
21if __name__ == "__main__":
22    main()

1import EdenClient from 'eden';
2
3async function main() {
4  const client = new EdenClient({ api_key: 'your-api-key' });
5
6  try {
7    const result = await client.query('SELECT id, name, email FROM users WHERE active = true');
8    
9    result.data.forEach(user => {
10      console.log(`User: ${user.name} (${user.email})`);
11    });
12  } catch (err) {
13    console.error("Error:", err);
14  }
15}
16
17main();

1package main
2
3import (
4	"fmt"
5	"log"
6	"os"
7
8	"github.com/eden-sdk/go-eden/eden"
9)
10
11func main() {
12	apiKey := os.Getenv("EDEN_API_KEY")
13	client, err := eden.NewClient(apiKey)
14	if err != nil {
15		log.Fatal(err)
16	}
17
18	query := "SELECT id, name, email FROM users WHERE active = true"
19	result, err := client.Query(query)
20	if err != nil {
21		log.Fatal(err)
22	}
23
24	for _, user := range result.Data {
25		name := user["name"].(string)
26		email := user["email"].(string)
27		fmt.Printf("User: %s (%s)\n", name, email)
28	}
29}

1require 'eden'
2
3def main
4  client = Eden::Client.new(api_key: ENV['EDEN_API_KEY'])
5
6  begin
7    result = client.query("SELECT id, name, email FROM users WHERE active = true")
8
9    result['data'].each do |user|
10      puts "User: #{user['name']} (#{user['email']})"
11    end
12
13  rescue Eden::Error => e
14    puts "Error: #{e.message}"
15  end
16end
17
18main

1<?php
2
3require_once 'vendor/autoload.php';
4
5use EdenClient;
6
7$apiKey = getenv('EDEN_API_KEY');
8$client = new Client(['api_key' => $apiKey]);
9
10try {
11  $result = $client->query("SELECT id, name, email FROM users WHERE active = true");
12
13  foreach ($result['data'] as $user) {
14    echo "User: " . $user["name"] . " (" . $user["email"] . ")\n";
15  }
16} catch (Exception $e) {
17  echo "Error: " . $e->getMessage() . "\n";
18}
19
20?>

1import kotlinx.coroutines.*
2import eden.EdenClient
3
4fun main() = runBlocking {
5    val apiKey = System.getenv("EDEN_API_KEY") ?: "YOUR_API_KEY"
6    val client = EdenClient(apiKey = apiKey)
7
8    try {
9        val result = client.query("SELECT id, name, email FROM users WHERE active = true")
10
11        result["data"]?.forEach { user ->
12            val name = user["name"] as String
13            val email = user["email"] as String
14            println("User: $name ($email)")
15        }
16    } catch (e: Exception) {
17        println("Error: ${e.message}")
18    }
19}

1using System;
2using System.Threading.Tasks;
3using Eden;
4
5class Program
6{
7    static async Task Main(string[] args)
8    {
9        string apiKey = Environment.GetEnvironmentVariable("EDEN_API_KEY") ?? "YOUR_API_KEY";
10        var client = new EdenClient(apiKey);
11
12        try
13        {
14            var result = await client.QueryAsync("SELECT id, name, email FROM users WHERE active = true");
15
16            foreach (var user in result.Data)
17            {
18                string name = (string)user["name"];
19                string email = (string)user["email"];
20                Console.WriteLine($"User: {name} ({email})");
21            }
22        }
23        catch (Exception e)
24        {
25            Console.WriteLine($"Error: {e.Message}");
26        }
27    }
28}

1use eden::EdenClient;
2use std::env;
3
4#[tokio::main]
5async fn main() -> Result<(), Box<dyn std::error::Error>> {
6    let api_key = env::var("EDEN_API_KEY").expect("EDEN_API_KEY must be set");
7    let client = EdenClient::new(&api_key);
8
9    let result = client.query("SELECT id, name, email FROM users WHERE active = true").await?;
10
11    if let Some(data) = result.data {
12        for user in data {
13            println!("User: {} ({})", user["name"].as_str().unwrap(), user["email"].as_str().unwrap());
14        }
15    }
16
17    Ok(())
18}

1#include <iostream>
2#include <cstdlib>
3#include "eden/client.h"
4
5int main() {
6    const char* api_key = std::getenv("EDEN_API_KEY");
7    if (!api_key) {
8        std::cerr << "EDEN_API_KEY environment variable not set." << std::endl;
9        return 1;
10    }
11
12    eden::Client client(api_key);
13
14    try {
15        auto result = client.query("SELECT id, name, email FROM users WHERE active = true");
16
17        for (const auto& user : result.data()) {
18            std::cout << "User: " << user.at("name").get<std::string>() << " (" << user.at("email").get<std::string>() << ")" << std::endl;
19        }
20    } catch (const eden::Exception& e) {
21        std::cerr << "Error: " << e.what() << std::endl;
22        return 1;
23    }
24
25    return 0;
26}

1library(eden)
2
3# Set your Eden API key
4api_key <- Sys.getenv("EDEN_API_KEY")
5
6# Initialize the Eden client
7client <- eden_client(api_key)
8
9# Execute the query
10result <- query(client, "SELECT id, name, email FROM users WHERE active = true")
11
12# Process the results
13for (i in 1:nrow(result$data)) {
14  print(paste("User:", result$data[i,"name"], "(", result$data[i,"email"], ")"))
15}
16