Base

func New(d *Deta, baseName string) (*Base, error)

import (
  "fmt"

  "github.com/deta/deta-go/deta"
  "github.com/deta/deta-go/service/base"
)

func main() {

  d, err := deta.New()
  if err != nil {
    fmt.Println("failed to init new Deta instance:", err)
    return
  }

  // initialize with base name
  // returns ErrBadBaseName if base name is invalid
  db, err := base.New(d, "base_name")
  if err != nil {
    fmt.Println("failed to init new Base instance:", err)
    return
  }
}

function Base(baseName: string, host?: string);

const { Deta } = require('deta'); // import Deta

const deta = Deta();

// This how to connect to or create a database.
const db = deta.Base('simple_db');

def Base(name: str, host: str | None = None):

from deta import Deta

deta = Deta()

# This how to connect to or create a database.
db = deta.Base("simple_db")

def AsyncBase(name: str):

from deta import Deta

deta = Deta()

# This how to connect to or create a database.
db = deta.AsyncBase("simple_db")

# Don't forget to close the session when you're done
await db.close()

func (b *Base) Put(item interface{}) (string, error)

item := map[string]interface{}{
    "key": "my-key",
    "value": "Hello world!",
}
key, err := db.Put(item)

async function put(
    data: DetaType,
    key?: string,
    options?: PutOptions,
): Promise<PutResponse>;

await base.put({ value: "Hello world!" }, "my-key");

def put(
    data: dict | list | str | int | float | bool,
    key: str | None = None,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

base.put({"value": "Hello world!"}, "my-key")

async def put(
    data: dict | list | str | int | float | bool,
    key: str | None = None,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

await base.put({"value": "Hello world!"}, "my-key")

async function get(key: string): Promise<GetResponse>;

const item = await base.get("my-key");

def get(key: str) -> dict | None:

item = base.get("my-key")

async def get(key: str) -> dict | None:

item = await base.get("my-key")

func (b *Base) Get(key string, dest interface{}) error

var item map[string]interface{}
err := db.Get("my-key", &item)

func (b *Base) Delete(key string) error

err := db.Delete("my-key")

async function delete(key: string): Promise<DeleteResponse>;

await base.delete("my-key");

def delete(key: str):

base.delete("my-key")

async def delete(key: str):

await base.delete("my-key")

func (b *Base) Insert(item interface{}) (string, error)

item := map[string]interface{}{
    "key": "my-key",
    "value": "Hello world!",
}
key, err := db.Insert(item)

async function insert(
data: DetaType,
key?: string,
options?: InsertOptions,
): Promise<InsertResponse>;

await base.insert({ value: "Hello world!" }, "my-key");

def insert(
    data: dict | list | str | int | float | bool,
    key: str | None = None,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

base.insert({"value": "Hello world!"}, "my-key")

async def insert(
    data: dict | list | str | int | float | bool,
    key: str | None = None,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

await base.insert({"value": "Hello world!"}, "my-key")

func (b *Base) PutMany(items interface{}) ([]string, error)

item1 := map[string]interface{}{
    "value": "First item",
}
item2 := map[string]interface{}{
    "value": "Second item",
}
items := []map[string]interface{}{item1, item2}
keys, err := db.PutMany(items)

async function putMany(
    items: DetaType[],
    options?: PutManyOptions,
): Promise<PutManyResponse>;

await base.putMany(["First item", "Second item", "Third item"]);

def put_many(
    items: list,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

base.put_many(["First item", "Second item", "Third item"])

async def put_many(
    items: list,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None,
) -> dict:

await base.put_many(["First item", "Second item", "Third item"])

func (b *Base) Update(key string, updates Updates) error

updates := base.Updates{
    "value": "Hello updated world!",
}
err := db.Update("my-key", updates)

async function update(
    updates: ObjectType,
    key: string,
    options?: UpdateOptions,
): Promise<UpdateResponse>;

await base.update(
    { value: "Hello updated world!" },
    "my-key",
);

def update(
    updates: dict,
    key: str,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None
)

base.update(
    {"value": "Hello updated world!"},
    "my-key",
)

async def update(
    updates: dict,
    key: str,
    *,
    expire_in: int | None = None,
    expire_at: int | float | datetime | None = None
)

await base.update(
    {"value": "Hello updated world!"},
    "my-key",
)

func (u *util) Increment(value interface{})

function increment(value?: number);

def increment(value: int | float = 1):

def increment(value: int | float = 1):

func (u *util) Append(value interface{})

function append(value: BasicType | ArrayType);

def append(value: dict | list | str | int | float | bool):

def append(value: dict | list | str | int | float | bool):

func (u *util) Prepend(value interface{})

function prepend(value: BasicType | ArrayType);

def prepend(value: dict | list | str | int | float | bool):

def prepend(value: dict | list | str | int | float | bool):

func (u *util) Trim()

function trim();

def trim():

def trim():

func (b *Base) Fetch(i *FetchInput) (string, error)

var results []map[string]interface{}
query := base.Query{
    {"value?contains": "world"},
}
_, err := db.Fetch(&base.FetchInput{
    Q: query,
    Dest: &results,
})

async function fetch(
    query?: CompositeType,
    options?: FetchOptions,
): Promise<FetchResponse>;

const response = await base.fetch({ "value?contains": "world" });

def fetch(
    self,
    query: Mapping | Sequence[Mapping] | None = None,
    *,
    limit: int = 1000,
    last: str | None = None,
    desc: bool = False,
) -> FetchResponse:

response = base.fetch({"value?contains": "world"})

async def fetch(
    self,
    query: Mapping | Sequence[Mapping] | None = None,
    *,
    limit: int = 1000,
    last: str | None = None,
    desc: bool = False,
) -> FetchResponse:

response = await base.fetch({"value?contains": "world"})