Examples
On this page you will find some more complex examples of using the Deta SDK.
Base
Put
import ( "log" "time"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { // JSON struct tag "key" used to denote the key. Key string `json:"key"` Username string `json:"username"` Active bool `json:"active"` Age int `json:"age"` Likes []string `json:"likes"` // JSON struct tag "__expires" for expiration timestamp. // "omitempty" for omission of default 0 value. Expires int64 `json:"__expires,omitempty"`}
func main() { // Errors ignored for brevity. d, _ := deta.New(deta.WithProjectKey("project_key")) db, _ := base.New(d, "users")
u := &User{ Key: "kasdlj1", Username: "jimmy", Active: true, Age: 20, Likes: []string{"ramen"}, } key, err := db.Put(u) if err != nil { log.Fatal("failed to put item:", err) } log.Println("Successfully put item with key", key)
// Can also use a map. um := map[string]interface{}{ "key": "kasdlj1", "username": "jimmy", "active": true, "age": 20, "likes": []string{"ramen"}, } key, err = db.Put(um) if err != nil { log.Fatal("Failed to put item:", err) } log.Println("Successfully put item with key:", key)
// Put with expiry date. u := &User{ Key: "will_be_deleted", Username: "test_user", Expires: time.Date(2023, 1, 1, 0, 0, 0, 0, 0, time.UTC).Unix(), } key, err = db.Put(u) if err != nil { log.Fatal("failed to put item:", err) } log.Println("Successfully put item with key:", key)
// Put map with expiry date. um = map[string]interface{}{ "key": "will_be_deleted", "test": true, "__expires": time.Data(2023, 1, 1, 0, 0, 0, 0, time.UTC).Unix(), } key, err = db.Put(um) if err != nil { log.Fatal("failed to put item:", err) } log.Println("Successfully put item with key:", key)}
const Deta = require('deta');
const deta = Deta(); //instantiate with Data Key or env DETA_PROJECT_KEY
const db = deta.Base("simple_db");
// Store objects.// A key will be automatically generated.await db.put({ name: "alex", age: 77 });// We will use "one" as a key.await db.put({ name: "alex", age: 77 }, "one");// The key could also be included in the object itself.await db.put({ name: "alex", age: 77, key: "one" });
// Store simple types.await db.put("hello, worlds");await db.put(7);// "success" is the value and "smart_work" is the key.await db.put("success", "smart_work");await db.put(["a", "b", "c"], "my_abc");
// Put expiring items.// Expire in 300 seconds.await db.put({ name: "alex", age: 21 }, "alex21", { expireIn: 300 });// Expire at date.await db.put({ name: "max", age: 28 }, "max28", { expireAt: new Date("2023-01-01T00:00:00") });
from deta import Deta
deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY
db = deta.AsyncBase("simple_db")
# Store objects.# A key will be automatically generated.await db.put({"name": "alex", "age": 77})# We will use "one" as a key.await db.put({"name": "alex", "age": 77}, "one")# The key could also be included in the object itself.await db.put({"name": "alex", "age": 77, "key": "one"})
# Simple types.await db.put("hello, worlds")await db.put(7)# "success" is the value and "smart_work" is the key.await db.put("success", "smart_work")await db.put(["a", "b", "c"], "my_abc")
# Expire in 300 seconds.await db.put({"name": "alex", "age": 23}, "alex23", expire_in=300)# Expire at date.expire_at = datetime.fromisoformat("2023-01-01T00:00:00")await db.put({"name": "max", "age": 28}, "max28", expire_at=expire_at)
# Close db sessionawait db.close()
from deta import Deta
deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY
db = deta.Base("simple_db")
# Store objects.# A key will be automatically generated.db.put({"name": "alex", "age": 77})# We will use "one" as a key.db.put({"name": "alex", "age": 77}, "one")# The key could also be included in the object itself.db.put({"name": "alex", "age": 77, "key": "one"})
# Simple types.db.put("hello, worlds")db.put(7)# "success" is the value and "smart_work" is the key.db.put("success", "smart_work")db.put(["a", "b", "c"], "my_abc")
# Expire in 300 seconds.db.put({"name": "alex", "age": 23}, "alex23", expire_in=300)# Expire at date.expire_at = datetime.fromisoformat("2023-01-01T00:00:00")db.put({"name": "max", "age": 28}, "max28", expire_at=expire_at)
Get
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { Key string `json:"key"` Username string `json:"username"` Active bool `json:"active"` Age int `json:"age"` Likes []string `json:"likes"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
// Declare a variable to store the result. var u User
// Get an item. err = db.Get("kasdlj1", &u) if err != nil { fmt.Println("Failed to get item:", err) }}
const item = await db.get('one'); // retrieving item with key "one"
If the record is found, the returned promise will resolve to an object, else null
:
{ name: 'alex', age: 77, key: 'one'}
item = db.get("one") # retrieving item with key "one"
If the record is found, will return an object, else None
:
{ "name": "alex", "age": 77, "key": "one"}
item = await db.get("one") # retrieving item with key "one"
# Close db sessionawait db.close()
If the record is found, will return an object, else None
:
{ "name": "alex", "age": 77, "key": "one"}
Insert
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { Key string `json:"key"` Username string `json:"username"` Active bool `json:"active"` Age int `json:"age"` Likes []string `json:"likes"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
u := &User{ Key: "kasdlj1", Username: "jimmy", Active: true, Age: 20, Likes: []string{"ramen"}, }
// Insert item into the Base. key, err := db.Insert(u) if err != nil { fmt.Println("Failed to insert item:", err) return } fmt.Println("Successfully inserted item with key:", key)}
const Deta = require('deta');
const deta = Deta(); //instantiate with Data Key or env DETA_PROJECT_KEY
const db = deta.Base("simple_db");
// Will succeed, a key will be auto-generated.const res1 = await db.insert("hello, world");
// Will succeed.const res2 = await db.insert({ message: "hello, world" }, "greeting1");
// Will raise an error as key "greeting1" already exists.const res3 = await db.insert({ message: "hello, there" }, "greeting1");
// Expire in 300 seconds.await db.insert({ message: "will be deleted" }, "temp_key", { expireIn: 300 });
// Expire at date.await db.insert({ message: "will be deleted" }, "temp_key_2", { expireAt: new Date("2023-01-01T00:00:00") });
from deta import Deta
deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY
db = deta.Base("simple_db")
# Will succeed, a key will be auto-generated.db.insert("hello, world")
# Will succeed.db.insert({"message": "hello, world"}, "greeting1")
# Will raise an error as key "greeting1" already exists.db.insert({"message": "hello, there"}, "greeting1")
# Expire in 300 seconds.db.insert({"message": "will be deleted"}, "temp_greeting", expire_in=300)
# Expire at date.expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")db.insert({"message": "will_be_deleted"}, "temp_greeting2", expire_at=expire_at)
from deta import Deta
deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY
db = deta.AsyncBase("simple_db")
# Will succeed, a key will be auto-generated.await db.insert("hello, world")
# Will succeed.await db.insert({"message": "hello, world"}, "greeting1")
# Will raise an error as key "greeting1" already exists.await db.insert({"message": "hello, there"}, "greeting1")
# Expire in 300 seconds.await db.insert({"message": "will be deleted"}, "temp_greeting", expire_in=300)
# Expire at date.expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")await db.insert({"message": "will_be_deleted"}, "temp_greeting2", expire_at=expire_at)
# Close db sessionawait db.close()
Put Many
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { Key string `json:"key"` Username string `json:"username"` Active bool `json:"active"` Age int `json:"age"` Likes []string `json:"likes"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
// Define two users. u1 := &User{ Key: "kasdlj1", Username: "jimmy", Active: true, Age: 20, Likes: []string{"ramen"}, } u2 := &User{ Key: "askdjf", Username: "joel", Active: true, Age: 23, Likes: []string{"coffee"}, } users := []*User{u1, u2}
// Put items into the Base. keys, err := db.PutMany(users) if err != nil { fmt.Println("Failed to put items:", err) return } fmt.Println("Successfully put items with keys:", keys)}
await db.putMany([ { name: "Beverly", hometown: "Copernicus City", key: "one" }, // Key provided. ["Namaskāra", "marhabaan", "hello", "yeoboseyo"], // Key auto-generated. "dude", // Key auto-generated.]);
// Put many to expire in 300 seconds.await db.putMany( [ { key: "temp-1", name: "test-1" }, { key: "temp-2", name: "test-2" }, ], { expireIn: 300 },);
// Put many with expiry date.await db.putMany( [ { key: "temp-1", name: "test-1" }, { key: "temp-2", name: "test-2" }, ], { expireAt: new Date("2023-01-01T00:00:00") },);
Example output:
{ "processed": { "items": [ { "hometown": "Copernicus City", "key": "one", "name": "Beverly" }, { "key": "5feqybn7lb05", "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"] }, { "key": "jyesxxlrezo0", "value": "dude" } ] }}
db.put_many([ {"name": "Beverly", "hometown": "Copernicus City", "key": "one"}, # Key provided. ["Namaskāra", "marhabaan", "hello", "yeoboseyo"], # Key auto-generated. "dude", # Key auto-generated.])
# Put many to expire in 300 seconds.db.put_many( [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}], expire_in=300,)
# Put many with expiry date.expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")db.put_many( [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}], expire_at=expire_at,)
Output example:
{ "processed": { "items": [ { "hometown": "Copernicus City", "key": "one", "name": "Beverly" }, { "key": "5feqybn7lb05", "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"] }, { "key": "jyesxxlrezo0", "value": "dude" } ] }}
await db.put_many([ {"name": "Beverly", "hometown": "Copernicus City", "key": "one"}, # Key provided. ["Namaskāra", "marhabaan", "hello", "yeoboseyo"], # Key auto-generated. "dude", # Key auto-generated.])
# Put many to expire in 300 seconds.await db.put_many( [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}], expire_in=300,)
# Put many with expiry date.expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")await db.put_many( [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}], expire_at=expire_at,)
# Close db sessionawait db.close()
Output example:
{ "processed": { "items": [ { "hometown": "Copernicus City", "key": "one", "name": "Beverly" }, { "key": "5feqybn7lb05", "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"] }, { "key": "jyesxxlrezo0", "value": "dude" } ] }}
Update
Assume we have the following item in a Base:
{ "key": "user-a", "username": "jimmy", "profile": { "age": 32, "active": false, "hometown": "pittsburgh" }, "on_mobile": true, "likes": ["anime"], "purchases": 1}
We will use update
, via an updates
dictionary / object.
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type Profile struct { Active bool `json:"active"` Age int `json:"age"` Hometown string `json:"hometown"`}
type User struct { Key string `json:"key"` Username string `json:"username"` Profile *Profile `json:"profile"` Purchases int `json:"purchases"` Likes []string `json:"likes"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
// Define the updates. updates := base.Updates{ "profile.age": 33, // Set "profile.age" to 33. "profile.active": true, // Set "profile.active" to true. "profile.hometown": db.Util.Trim(), // Remove "profile.hometown". "purchases": db.Util.Increment(2), // Increment "purchases" by 2. "likes": db.Util.Append("ramen"), // Append "ramen" to "likes". } // Update an item. err = db.Update("user-a", updates) if err != nil { fmt.Println("Failed to update item:", err) return }}
const updates = { "profile.age": 33, // Set "profile.age" to 33. "profile.active": true, // Set "profile.active" to true. "profile.hometown": users.util.trim(), // Remove "profile.hometown". on_mobile: users.util.trim(), // Remove "on_mobile". purchases: users.util.increment(2), // Increment "purchases" by 2. likes: users.util.append("ramen"), // Append "ramen" to "likes".};
const res = await db.update(updates, "user-a");
updates = { "profile.age": 33, # Set "profile.age" to 33. "profile.active": True, # Set "profile.active" to true. "profile.hometown": users.util.trim(), # Remove "profile.hometown". "on_mobile": users.util.trim(), # Remove "on_mobile". "purchases": users.util.increment(2), # Increment by 2. "likes": users.util.append("ramen"), # Append "ramen" to "likes".}
db.update(updates, "user-a")
updates = { "profile.age": 33, # Set "profile.age" to 33. "profile.active": True, # Set "profile.active" to true. "profile.hometown": users.util.trim(), # Remove "profile.hometown". "on_mobile": users.util.trim(), # Remove "on_mobile". "purchases": users.util.increment(2), # Increment by 2. "likes": users.util.append("ramen"), # Append "ramen" to "likes".}
await db.update(updates, "user-a")
# Close db sessionawait db.close()
The above updates result in the following item in the Base:
{ "key": "user-a", "username": "jimmy", "profile": { "age": 33, "active": true, }, "likes": ["anime", "ramen"], "purchases": 3}
Fetch
If we have the following items in a Base:
[ { "key": "key-1", "name": "Wesley", "age": 27, "hometown": "San Francisco" }, { "key": "key-2", "name": "Beverly", "age": 51, "hometown": "Copernicus City" }, { "key": "key-3", "name": "Kevin Garnett", "age": 43, "hometown": "Greenville" }]
Then the following fetch calls:
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { Key string `json:"key"` Name string `json:"name"` Age int `json:"age"` Hometown string `json:"hometown"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
// Query to get users with age less than 30. query := base.Query{ {"age?lt": 50}, }
// Declare a variable to store the results. var results []*User
// Fetch items. _, err = db.Fetch(&base.FetchInput{ Q: query, Dest: &results, }) if err != nil { fmt.Println("Failed to fetch items:", err) }}
results
will have the following data:
[ { "key": "key-1", "name": "Wesley", "age": 27, "hometown": "San Francisco" }, { "key": "key-3", "name": "Kevin Garnett", "age": 43, "hometown": "Greenville" }]
const { items: firstResult } = await db.fetch({ "age?lt": 30 });const { items: secondResult } = await db.fetch([{ "age?gt": 50 }, { hometown: "Greenville" }]);
will return following data:
firstResult
:
[ { "key": "key-1", "name": "Wesley", "age": 27, "hometown": "San Francisco" }]
secondResult
:
[ { "key": "key-2", "name": "Beverly", "age": 51, "hometown": "Copernicus City" }, { "key": "key-3", "name": "Kevin Garnett", "age": 43, "hometown": "Greenville" }]
first_result = db.fetch({"age?lt": 30})second_result = db.fetch([{"age?gt": 50}, {"hometown": "Greenville"}])
will return following data:
first_result.items
:
[ { "key": "key-1", "name": "Wesley", "age": 27, "hometown": "San Francisco" }]
second_result.items
:
[ { "key": "key-2", "name": "Beverly", "age": 51, "hometown": "Copernicus City" }, { "key": "key-3", "name": "Kevin Garnett", "age": 43, "hometown": "Greenville" }]
first_result = await db.fetch({"age?lt": 30})second_result = await db.fetch([{"age?gt": 50}, {"hometown": "Greenville"}])
# Close db sessionawait db.close()
will return following data:
first_result.items
:
[ { "key": "key-1", "name": "Wesley", "age": 27, "hometown": "San Francisco" }]
second_result.items
:
[ { "key": "key-2", "name": "Beverly", "age": 51, "hometown": "Copernicus City" }, { "key": "key-3", "name": "Kevin Garnett", "age": 43, "hometown": "Greenville" }]
Fetch All Items
The following snippet will fetch all items from a Base:
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/base")
type User struct { Key string `json:"key"` Username string `json:"username"` Active bool `json:"active"` Age int `json:"age"` Likes []string `json:"likes"`}
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
db, err := base.New(d, "users") if err != nil { fmt.Println("Failed to init new Base instance:", err) }
// Query to get users with age less than 30. query := base.Query{ {"age?lt": 50}, }
// Declare a variable to store the results. var results []*User
// Declare a variable to store the page. var page []*User
// Define fetch input. i := &base.FetchInput{ Q: query, Dest: &page, Limit: 1, // Limit provided so each page will only have one item. }
// Fetch items. lastKey, err := db.Fetch(i) if err != nil { fmt.Println("Failed to fetch items:", err) return }
// Append the page items to the results. results = append(results, page...)
// Get all pages. for lastKey != "" { // Provide the last key in the fetch input. i.LastKey = lastKey
// Fetch items. lastKey, err = db.Fetch(i) if err != nil { fmt.Println("Failed to fetch items:", err) return }
// Append the page items to the results. results = append(results, page...) }}
let res = await db.fetch();let allItems = res.items;
// Continue fetching until "res.last" is undefined.while (res.last) { res = await db.fetch({}, { last: res.last }); allItems = allItems.concat(res.items);}
res = db.fetch()all_items = res.items
# Continue fetching until "res.last" is None.while res.last: res = db.fetch(last=res.last) all_items += res.items
res = await db.fetch()all_items = res.items
# Continue fetching until "res.last" is None.while res.last: res = await db.fetch(last=res.last) all_items += res.items
# Close db sessionawait db.close()
Drive
Put
Async not supported yet.
import ( "bufio" "fmt" "os"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/drive")
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
drawings, err := drive.New(d, "drawings") if err != nil { fmt.Println("Failed to init new Drive instance:", err) return }
// Put a file from a local path. file, err := os.Open("./art.svg") defer file.Close()
name, err := drawings.Put(&drive.PutInput{ Name: "art.svg", Body: bufio.NewReader(file), ContentType: "image/svg+xml", }) if err != nil { fmt.Println("Failed to put file:", err) return } fmt.Println("Successfully put file with name:", name)}
// Provide content directly.drive.put("hello.txt", {data: "Hello world"});drive.put("hello.txt", {data: "Hello world", contentType: "text/plain"});
// Provide a content buffer.drive.put("hello.txt", {data: Buffer.from("Hello World"), contentType: "text/plain"});
// Provide a path to a file.drive.put("hello.txt", {path: "./my/file/path/file.txt"});drive.put("hello.txt", {path: "./my/file/path/file.txt", contentType: "text/plain"});
# Provide content directly.drive.put("hello.txt", "Hello world")drive.put(b"hello.txt", "Hello world")drive.put("hello.txt", content_type="text/plain")
import io
# Provide a file-like object.drive.put("hello.txt", io.StringIO("hello world"))drive.put("hello.txt", io.BytesIO(b"hello world"))
f = open("./hello.txt", "r")drive.put("hello.txt", f)f.close()
# Provide a path to a file.drive.put("hello.txt", path="./hello.txt")
Get
Async not supported yet.
const buf = await drive.get("hello.txt");
import ( "fmt" "io/ioutil"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/drive")
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
drawings, err := drive.New(d, "drawings") if err != nil { fmt.Println("Failed to init new Drive instance:", err) return }
// Get a file with a name. name := "art.svg" f, err := drawings.Get(name) if err != nil { fmt.Println("Failed to get file with name:", name) return } defer f.Close()
// Read the file content. c, err := ioutil.ReadAll(f) if err != nil { fmt.Println("Failed read file content with err:", err) return } fmt.Println("File content:", string(c))}
hello = drive.get("hello.txt")content = hello.read()hello.close()
# For a larger file, iterate chunks of size 4096 and save to disk.large_file = drive.get("large_file.txt")with open("large_file.txt", "wb+") as f: for chunk in large_file.iter_chunks(4096): f.write(chunk) large_file.close()
Delete
Async not supported yet.
const deletedFile = await drive.delete("hello.txt");
deleted_file = drive.delete("hello.txt")
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/drive")
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
drawings, err := drive.New(d, "drawings") if err != nil { fmt.Println("Failed to init new Drive instance:", err) return }
// Delete a file with a name. name, err := drawings.Delete("art.svg") if err != nil { fmt.Println("Failed to delete file with name:", name) return } fmt.Println("Successfully deleted file with name:", name)}
Delete Many
Async not supported yet.
const result = await drive.DeleteMany(["file1.txt", "file2.txt", "file3.txt"]);
result = drive.delete_many(["file1.txt", "file2.txt", "file3.txt"])
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/drive")
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
drawings, err := drive.New(d, "drawings") if err != nil { fmt.Println("Failed to init new Drive instance:", err) return }
names := []string{"a", "b", "c"} dr, err := drawings.DeleteMany(names)
if err != nil { fmt.Println("Failed to delete files", err) return }
fmt.Println("Deleted:", dr.Deleted) fmt.Println("Failed:", dr.Failed)
}
An output includes a list
/ array
of successfully deleted files, and a dict
/ object
of failures with reasons:
{ "deleted": ["file1.txt", "file2.txt"], "failed": { "file3.txt": "reason for failure" }}
List
The following snippet will list all files in a Drive:
Async not supported yet.
import ( "fmt"
"github.com/deta/deta-go/deta" "github.com/deta/deta-go/service/drive")
func main() { d, err := deta.New(deta.WithProjectKey("project_key")) if err != nil { fmt.Println("Failed to init new Deta instance:", err) return }
drawings, err := drive.New(d, "drawings") if err != nil { fmt.Println("Failed to init new Drive instance:", err) return }
lr, err := drawings.List(1000, "", "") if err != nil { fmt.Println("Failed to list names from drive with err:", err) } fmt.Println("Names:", lr.Names) // ["a", "b", "c/d"]
lr, err = drawings.List(1, "", "") if err != nil { fmt.Println("Failed to list names from drive with err:", err) } fmt.Println("Names:", lr.Names) // ["a"]
lr, err = drawings.List(2, "", "") if err != nil { fmt.Println("Failed to list names from drive with err:", err) } fmt.Println("Last:", *lr.Paging.Last) // "b"}
let result = await drive.list();let allFiles = result.names;let last = result.paging.last;
while (last) { // Provide "last" from previous call. result = await drive.list({ last: result.paging.last }); allFiles = allFiles.concat(result.names); last = result.paging.last;}console.log("all files:", allFiles);
const resultWithPrefix = await drive.list({ prefix: "blog/" });const resultWithLimit = await drive.list({ limit: 100 });const resultWithLimitAndPrefix = await drive.list({ limit: 100, prefix: "blog/",});
result = drive.list()all_files = result.get("names")last = result.get("paging", {}).get("last", None)
while last: # Provide "last" from previous call. result = drive.list(last=last) all_files += result.get("names") last = result.get("paging", {}).get("last", None)
print("all files:", all_files)
res_with_prefix = drive.list(prefix="/blog")res_with_limit = drive.list(limit=100)res_with_prefix_limit = drive.list(prefix="/blog", limit=100)
Outputs of list include a dict / object with paging
and names
keys.
{ "names": ["file1.txt", "file2.txt"], "paging": { "size": 2, "last": "file2.txt" }}