Surreal

from surrealdb import Surreal

db = Surreal(url)

from surrealdb import AsyncSurreal

db = AsyncSurreal(url)

from surrealdb import Surreal

db = Surreal("ws://localhost:8000")

from surrealdb import Surreal

db = Surreal("https://cloud.surrealdb.com")

from surrealdb import Surreal

db = Surreal("mem://")

from surrealdb import Surreal

db = Surreal("surrealkv://path/to/database")

from surrealdb import AsyncSurreal

db = AsyncSurreal("ws://localhost:8000")

db.connect(url)

from surrealdb import Surreal

db = Surreal("ws://localhost:8000")
db.connect()

from surrealdb import AsyncSurreal

db = AsyncSurreal("ws://localhost:8000")
await db.connect()

db = Surreal("ws://localhost:8000")
db.connect("ws://other-host:8000")

db.close()

db.close()

await db.close()

db.use(namespace, database)

db.use("my_namespace", "my_database")

await db.use("my_namespace", "my_database")

db.version()

ver = db.version()
print(ver)  # e.g. "surrealdb-2.2.0"

ver = await db.version()
print(ver)

db.signup(vars)

token = db.signup({
    "namespace": "my_namespace",
    "database": "my_database",
    "access": "user_access",
    "email": "user@example.com",
    "password": "s3cret",
})

token = await db.signup({
    "namespace": "my_namespace",
    "database": "my_database",
    "access": "user_access",
    "email": "user@example.com",
    "password": "s3cret",
})

db.signin(vars)

token = db.signin({
    "username": "root",
    "password": "root",
})

token = await db.signin({
    "username": "root",
    "password": "root",
})

token = db.signin({
    "namespace": "my_namespace",
    "database": "my_database",
    "access": "user_access",
    "email": "user@example.com",
    "password": "s3cret",
})

db.authenticate(token)

db.authenticate("eyJhbGciOiJIUzI1NiIs...")

await db.authenticate("eyJhbGciOiJIUzI1NiIs...")

db.invalidate()

db.invalidate()

await db.invalidate()

db.info()

user = db.info()
print(user)  # e.g. {"id": "users:john", "email": "john@example.com"}

user = await db.info()

db.let(key, value)

db.let("user_id", RecordID("users", "john"))
result = db.query("SELECT * FROM users WHERE id = $user_id")

await db.let("user_id", RecordID("users", "john"))
result = await db.query("SELECT * FROM users WHERE id = $user_id")

db.unset(key)

db.unset("user_id")

await db.unset("user_id")

db.query(query, vars)

result = await db.query(
    "SELECT * FROM users WHERE age > $min_age",
    {"min_age": 18},
)

people, count = await db.query(
    "SELECT * FROM person; SELECT count() FROM person GROUP ALL"
)

from dataclasses import dataclass

@dataclass
class Stats:
    people: list
    count: list

stats = await db.query(
    "SELECT * FROM person; SELECT count() FROM person GROUP ALL"
).into(Stats)

# The sync builder auto-executes when consumed (indexed, iterated, compared, etc.).
# For fire-and-forget statements call .execute() explicitly.
people = db.query("SELECT * FROM users")
print(len(people))
db.query("DELETE temp_data;").execute()

db.query_raw(query, params)

raw = db.query_raw(
    "CREATE users SET name = $name; SELECT * FROM users;",
    {"name": "John"},
)

for statement in raw["result"]:
    print(statement["status"], statement["time"])

raw = await db.query_raw(
    "CREATE users SET name = $name; SELECT * FROM users;",
    {"name": "John"},
)

db.select(record)

users = db.select("users")

user = db.select(RecordID("users", "john"))

users = await db.select("users")

user = await db.select(RecordID("users", "john"))

db.create(record, data)

user = db.create("users", {
    "name": "John",
    "email": "john@example.com",
})

product = db.create(RecordID("products", "apple"), {
    "name": "Apple",
    "price": 1.50,
})

user = await db.create("users", {
    "name": "John",
    "email": "john@example.com",
})

db.update(record, data)

db.update(RecordID("users", "john"), {
    "name": "John Doe",
    "email": "john.doe@example.com",
})

await db.update(RecordID("users", "john"), {
    "name": "John Doe",
    "email": "john.doe@example.com",
})

db.upsert(record, data)

db.upsert(RecordID("users", "john"), {
    "name": "John",
    "email": "john@example.com",
})

await db.upsert(RecordID("users", "john"), {
    "name": "John",
    "email": "john@example.com",
})

db.update(RecordID("users", "john")).merge({"age": 32})

await db.update(RecordID("users", "john")).merge({"age": 32})

db.update(RecordID("users", "john")).patch([
    {"op": "replace", "path": "/email", "value": "new@example.com"},
    {"op": "add", "path": "/verified", "value": True},
])

await db.update(RecordID("users", "john")).patch([
    {"op": "replace", "path": "/email", "value": "new@example.com"},
])

db.delete(record)

db.delete(RecordID("users", "john"))

db.delete("temp_data")

await db.delete(RecordID("users", "john"))

db.insert(table, data)

db.insert("users", {"name": "Alice", "email": "alice@example.com"})

db.insert("users", [
    {"name": "Bob", "email": "bob@example.com"},
    {"name": "Charlie", "email": "charlie@example.com"},
])

await db.insert("users", {"name": "Alice", "email": "alice@example.com"})

db.insert("likes", {
    "in": RecordID("users", "alice"),
    "out": RecordID("posts", "post1"),
}, relation=True)

# Or via the builder:
db.insert("likes").relation().content({
    "in": RecordID("users", "alice"),
    "out": RecordID("posts", "post1"),
})

await db.insert("likes", {
    "in": RecordID("users", "alice"),
    "out": RecordID("posts", "post1"),
}, relation=True)

db.run(name, args, version)

result = db.run("fn::increment", [1])

greeting = await db.run("fn::greet", ["world"])

db.live(table, diff)

query_uuid = db.live("users")

query_uuid = db.live("users", diff=True)

query_uuid = await db.live("users")

db.subscribe_live(query_uuid)

query_uuid = db.live("users")

for notification in db.subscribe_live(query_uuid):
    print(notification["action"], notification["result"])

query_uuid = await db.live("users")

async for notification in db.subscribe_live(query_uuid):
    print(notification["action"], notification["result"])

db.kill(query_uuid)

db.kill(query_uuid)

await db.kill(query_uuid)

db.new_session()

session = db.new_session()
session.use("other_ns", "other_db")
result = session.select("users")

session = await db.new_session()
await session.use("other_ns", "other_db")
result = await session.select("users")

db.attach()

session_id = db.attach()

session_id = await db.attach()

db.detach(session_id)

db.detach(session_id)

await db.detach(session_id)

db.begin(session_id)

txn_id = db.begin()

txn_id = await db.begin()

session_id = db.attach()
txn_id = db.begin(session_id)

db.commit(txn_id, session_id)

txn_id = db.begin()
db.query("CREATE users SET name = 'Alice'")
db.commit(txn_id)

txn_id = await db.begin()
await db.query("CREATE users SET name = 'Alice'")
await db.commit(txn_id)

db.cancel(txn_id, session_id)

txn_id = db.begin()
db.query("DELETE users")
db.cancel(txn_id)

txn_id = await db.begin()
await db.query("DELETE users")
await db.cancel(txn_id)

from surrealdb import Surreal

with Surreal("ws://localhost:8000") as db:
    db.use("my_namespace", "my_database")
    db.signin({"username": "root", "password": "root"})
    users = db.select("users")

from surrealdb import AsyncSurreal

async with AsyncSurreal("ws://localhost:8000") as db:
    await db.use("my_namespace", "my_database")
    await db.signin({"username": "root", "password": "root"})
    users = await db.select("users")

from surrealdb import Surreal, RecordID

with Surreal("ws://localhost:8000") as db:
    db.use("shop", "inventory")
    db.signin({"username": "root", "password": "root"})

    db.create("products", {"name": "Laptop", "price": 999.99})
    db.create("products", {"name": "Mouse", "price": 29.99})

    products = db.select("products")
    print("All products:", products)

    cheap = db.query(
        "SELECT * FROM products WHERE price < $max",
        {"max": 100},
    )
    print("Affordable:", cheap)

    db.update(RecordID("products", products[0]["id"].id)).merge({"stock": 50})

    db.delete(RecordID("products", products[1]["id"].id))

import asyncio
from surrealdb import AsyncSurreal, RecordID

async def main():
    async with AsyncSurreal("ws://localhost:8000") as db:
        await db.use("shop", "inventory")
        await db.signin({"username": "root", "password": "root"})

        await db.create("products", {"name": "Laptop", "price": 999.99})

        products = await db.select("products")
        print("Products:", products)

asyncio.run(main())