Il datastore del pacchetto fornisce un client per il servizio datastore di App Engine.
Operazioni di base
Le entità sono l'unità di archiviazione e sono associate a una chiave. Una chiave è composta da una chiave padre facoltativa, un ID applicazione stringa, un tipo di stringa (noto anche come tipo di entità) e un StringID o un IntID. Un StringID è noto anche come nome dell'entità o nome della chiave.
È possibile creare una chiave con un valore StringID pari a zero e un IntID pari a zero. Si tratta di una chiave incompleta e non fa riferimento ad alcuna entità salvata. L'inserimento di un'entità nel datastore sotto una chiave incompleta produrrà una chiave univoca per l'entità con un IntID diverso da zero.
I contenuti di un'entità sono una mappatura dai nomi dei campi sensibili alle maiuscole ai valori. I tipi di valore validi sono:
- numeri interi firmati (int, int8, int16, int32 e int64),
- bool,
- stringa,
- float32 e float64,
- []byte (fino a 1 megabyte di lunghezza),
- qualsiasi tipo il cui tipo sottostante è uno dei tipi predichiarati sopra,
- ByteString,
- *Chiave,
- time.Time (memorizzati con precisione in microsecondi),
- appengine.BlobKey
- appengine.GeoPoint
- struct i cui campi sono tutti tipi di valori validi,
- di uno qualsiasi degli elementi sopra citati.
Le sezioni degli struct sono validi, così come gli struct che contengono le sezioni. Tuttavia, se uno struct ne contiene un altro, è possibile ripeterlo al massimo. Ciò disattiva i tipi di struct definiti in modo ricorsivo: qualsiasi struct T che (direttamente o indirettamente) contiene un []T.
Le funzioni Get e Put consentono di caricare e salvare i contenuti di un'entità. I contenuti di un'entità in genere sono rappresentati da un puntatore struct.
Esempio di codice:
type Entity struct {
Value string
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
e := new(Entity)
if err := datastore.Get(ctx, k, e); err != nil {
http.Error(w, err.Error(), 500)
return
}
old := e.Value
e.Value = r.URL.Path
if _, err := datastore.Put(ctx, k, e); err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "old=%q\nnew=%q\n", old, e.Value)
}
GetMulti, PutMulti ed DeleteMulti sono versioni batch delle funzioni Get, Put ed Delete. Ricevono una chiave []*anziché una *chiave e possono restituire un appengine.MultiError quando si verificano errori parziali.
Proprietà
I contenuti di un'entità possono essere rappresentati in vari tipi. In genere si tratta di puntatori struct, ma possono essere anche qualsiasi tipo che implementi l'interfaccia PropertyLoadSaver. Se utilizzi un puntatore struct, non è necessario implementare esplicitamente l'interfaccia PropertyLoadSaver poiché il datastore eseguirà automaticamente la conversione tramite il riflesso. Se un puntatore struct implementa quell'interfaccia, questi metodi verranno utilizzati in preferenza rispetto al comportamento predefinito dei puntatori struct. I puntatori struct sono più digitati e sono più facili da usare, mentre i valori PropertyLoadSavers sono più flessibili.
I tipi effettivi trasmessi non devono necessariamente corrispondere tra le chiamate Get e Put o persino in diverse chiamate al datastore. È valido inserire un *PropertyList e ottenere la stessa entità di *myStruct, oppure inserire un oggetto *myStruct0 e ottenere un *myStruct1. Concettualmente, qualsiasi entità viene salvata come sequenza di proprietà e viene caricata nel valore di destinazione in base alle singole proprietà. Durante il caricamento in un puntatore struct, un'entità che non può essere rappresentata completamente (ad esempio un campo mancante) genererà un errore ErrFieldMismatch, ma spetta al chiamante se questo errore è irreversibile, recuperabile o ignorabile.
Per impostazione predefinita, per i puntatori struct, tutte le proprietà sono potenzialmente indicizzate e il nome della proprietà corrisponde a quello del campo (e quindi deve iniziare con una lettera maiuscola).
I campi potrebbero avere un tag datastore:"name,options". Il nome del tag è il
nome della proprietà, che deve essere uno o più identificatori Go validi uniti da ".",
ma può iniziare con una lettera minuscola. Un nome di tag vuoto indica di
utilizzare solo il nome del campo. Se il nome del tag è "-", il datastore ignorerà questo campo.
Le uniche opzioni valide sono "omitempty" e "noindex".
Se le opzioni includono "omitempty" e il valore del campo è vuoto, il campo verrà omesso durante il salvataggio. I valori vuoti sono false, 0, qualsiasi valore di interfaccia nullo e qualsiasi array, sezione, mappa o stringa di lunghezza zero. I valori dei campi struct non saranno mai vuoti.
Se le opzioni includono "noindex", il campo non verrà indicizzato. Tutti i campi sono indicizzati per impostazione predefinita. Le stringhe o le sezioni di byte più lunghe di 1500 byte non possono essere indicizzate; i campi utilizzati per archiviare stringhe lunghe e sezioni di byte devono essere contrassegnati con "noindex", altrimenti le operazioni put non andranno a buon fine.
Per utilizzare più opzioni insieme, separale con una virgola. L'ordine non è importante.
Se l'opzione è "", la virgola potrebbe essere omessa.
Esempio di codice:
// A and B are renamed to a and b.
// A, C and J are not indexed.
// D's tag is equivalent to having no tag at all (E).
// I is ignored entirely by the datastore.
// J has tag information for both the datastore and json packages.
type TaggedStruct struct {
A int `datastore:"a,noindex"`
B int `datastore:"b"`
C int `datastore:",noindex"`
D int `datastore:""`
E int
I int `datastore:"-"`
J int `datastore:",noindex" json:"j"`
}
Proprietà strutturate
Se lo struct rimanda a contiene altri struct, gli struct nidificati o incorporati vengono appiattiti. Ad esempio, date queste definizioni:
type Inner1 struct {
W int32
X string
}
type Inner2 struct {
Y float64
}
type Inner3 struct {
Z bool
}
type Outer struct {
A int16
I []Inner1
J Inner2
Inner3
}
le proprietà di un Esterno sarebbero equivalenti a quelle di:
type OuterEquivalent struct {
A int16
IDotW []int32 `datastore:"I.W"`
IDotX []string `datastore:"I.X"`
JDotY float64 `datastore:"J.Y"`
Z bool
}
Se il campo Inner3 incorporato di Outer fosse taggato come datastore:"Foo", il
campo equivalente sarebbe invece: FooDotZ bool datastore:"Foo.Z".
Se uno struct esterno è contrassegnato con "noindex", tutti i campi impliciti suddivisi sono effettivamente "noindex".
Interfaccia PropertyLoadSaver
I contenuti di un'entità possono anche essere rappresentati da qualsiasi tipo che implementa l'interfaccia PropertyLoadSaver. Questo tipo può essere un puntatore struct, ma non è necessario. Il pacchetto datastore chiama Load quando ottiene i contenuti dell'entità e Salva quando inserisce i contenuti dell'entità. I possibili utilizzi includono la derivazione di campi non archiviati, la verifica dei campi o l'indicizzazione di un campo solo se il suo valore è positivo.
Esempio di codice:
type CustomPropsExample struct {
I, J int
// Sum is not stored, but should always be equal to I + J.
Sum int `datastore:"-"`
}
func (x *CustomPropsExample) Load(ps []datastore.Property) error {
// Load I and J as usual.
if err := datastore.LoadStruct(x, ps); err != nil {
return err
}
// Derive the Sum field.
x.Sum = x.I + x.J
return nil
}
func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
// Validate the Sum field.
if x.Sum != x.I + x.J {
return nil, errors.New("CustomPropsExample has inconsistent sum")
}
// Save I and J as usual. The code below is equivalent to calling
// "return datastore.SaveStruct(x)", but is done manually for
// demonstration purposes.
return []datastore.Property{
{
Name: "I",
Value: int64(x.I),
},
{
Name: "J",
Value: int64(x.J),
},
}, nil
}
Il tipo *PropertyList implementa PropertyLoadSaver e, pertanto, può contenere i contenuti di un'entità arbitraria.
Query
Le query recuperano le entità in base alle loro proprietà o alla discendenza della chiave. L'esecuzione di una query restituisce un iteratore dei risultati: chiavi o coppie (chiave, entità). Le query sono riutilizzabili ed è sicuro chiamare Query.Run da query simultanee. Gli iteratori non possono essere utilizzati contemporaneamente.
Le query sono immutabili e vengono create chiamando NewQuery o derivate da una query esistente chiamando un metodo come Filtro o Ordine che restituisce un nuovo valore di query. In genere una query viene creata chiamando NewQuery seguita da una catena di zero o più metodi di questo tipo. Questi metodi sono:
- L'antenato e il filtro limitano le entità restituite eseguendo una query.
- L'ordine influisce sull'ordine in cui vengono restituiti.
- Il progetto vincola i campi restituiti.
- Deduplica entità previste distinte.
- KeysOnly fa sì che l'iteratore restituisca solo chiavi, non coppie (chiave, entità).
- Inizio, Fine, Offset e Limite definiscono la sequenza secondaria di entità corrispondenti da restituire. I cursori di inizio e fine, Offset e Limite prendono numeri interi. Inizio e Offset influiscono sul primo risultato, mentre Fine e Limite influiscono sull'ultimo risultato. Se sono impostati sia Inizio che Offset, l'offset sarà relativo a Inizio. Se sono impostati sia Fine che Limite, prevale il primo vincolo. Il limite è relativo a Inizio + Offset, non a Fine. Nel caso speciale, un limite negativo significa che è illimitato.
Esempio di codice:
type Widget struct {
Description string
Price int
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
q := datastore.NewQuery("Widget").
Filter("Price <", 1000).
Order("-Price")
b := new(bytes.Buffer)
for t := q.Run(ctx); ; {
var x Widget
key, err := t.Next(&x)
if err == datastore.Done {
break
}
if err != nil {
serveError(ctx, w, err)
return
}
fmt.Fprintf(b, "Key=%v\nWidget=%#v\n\n", key, x)
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
io.Copy(w, b)
}
Transazioni
RunInTransaction esegue una funzione in una transazione.
Esempio di codice:
type Counter struct {
Count int
}
func inc(ctx context.Context, key *datastore.Key) (int, error) {
var x Counter
if err := datastore.Get(ctx, key, &x); err != nil && err != datastore.ErrNoSuchEntity {
return 0, err
}
x.Count++
if _, err := datastore.Put(ctx, key, &x); err != nil {
return 0, err
}
return x.Count, nil
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
var count int
err := datastore.RunInTransaction(ctx, func(ctx context.Context) error {
var err1 error
count, err1 = inc(ctx, datastore.NewKey(ctx, "Counter", "singleton", 0, nil))
return err1
}, nil)
if err != nil {
serveError(ctx, w, err)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "Count=%d", count)
}
Metadati
Il pacchetto datastore fornisce l'accesso ad alcuni metadati del datastore di App Engine. Questi metadati includono informazioni su gruppi di entità, spazi dei nomi, tipi di entità e proprietà nel datastore, nonché le rappresentazioni delle proprietà per ogni proprietà.
Esempio di codice:
func handle(w http.ResponseWriter, r *http.Request) {
// Print all the kinds in the datastore, with all the indexed
// properties (and their representations) for each.
ctx := appengine.NewContext(r)
kinds, err := datastore.Kinds(ctx)
if err != nil {
serveError(ctx, w, err)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
for _, kind := range kinds {
fmt.Fprintf(w, "%s:\n", kind)
props, err := datastore.KindProperties(ctx, kind)
if err != nil {
fmt.Fprintln(w, "\t(unable to retrieve properties)")
continue
}
for p, rep := range props {
fmt.Fprintf(w, "\t-%s (%s)\n", p, strings.Join(rep, ", "))
}
}
}
Variabili
ErrInvalidEntityType, ErrInvalidKey, ErrNoSuchEntity
var (
// ErrInvalidEntityType is returned when functions like Get or Next are
// passed a dst or src argument of invalid type.
ErrInvalidEntityType = errors.New("datastore: invalid entity type")
// ErrInvalidKey is returned when an invalid key is presented.
ErrInvalidKey = errors.New("datastore: invalid key")
// ErrNoSuchEntity is returned when no entity was found for a given key.
ErrNoSuchEntity = errors.New("datastore: no such entity")
)Fine
Il valore "Fine" viene restituito al termine dell'iterazione della query.
TransazioneSimultanea
ErrConcurrentTransaction viene restituito quando una transazione viene sottoposta a rollback a causa di un conflitto con una transazione contemporanea.
Funzioni
func AllocateIDRange
AllocateIDRange alloca un intervallo di ID con endpoint specifici. L'intervallo è inclusivo sia per la fascia bassa che per quella alta. Una volta assegnati questi ID, puoi assegnarli manualmente alle entità appena create.
L'allocatore automatico di ID Datastore non assegna mai una chiave già allocata (tramite l'allocazione automatica di ID o una chiamata AllocateIDs esplicita). Di conseguenza, le entità scritte nell'intervallo di chiavi specificato non verranno mai sovrascritte. Tuttavia, la scrittura di entità con chiavi assegnate manualmente in questo intervallo potrebbe sovrascrivere le entità esistenti (o nuove entità scritte da una richiesta separata), a seconda dell'errore restituito.
Utilizza questa opzione solo se disponi già di un intervallo di ID numerici che vuoi prenotare (ad esempio, entità di caricamento collettivo che hanno già ID). Se non ti interessa quali ID ricevi, utilizza invece gli AllocateID.
AllocateIDRange restituisce zero se l'intervallo è stato allocato correttamente. Se esistono già una o più entità con un ID nell'intervallo specificato, viene restituito un valore KeyRangeCollisionError. Se Datastore ha già memorizzato nella cache gli ID in questo intervallo (ad es. da una chiamata precedente ad AllocateIDRange), restituisce un valore KeyRangeContentionError. Errori di altro tipo indicano problemi con gli argomenti o un errore restituito direttamente da Datastore.
func AllocateID
AllocateIDs restituisce un intervallo di n ID interi con il tipo e la combinazione padre specificati. Il tipo non può essere vuoto; l'elemento padre potrebbe essere zero. Gli ID nell'intervallo restituito non verranno utilizzati dal generatore di sequenza di ID automatico del datastore e potrebbero essere usati con NewKey senza conflitti.
L'intervallo è inclusivo per il segmento più basso ed esclusivo per il segmento più alto. In altre parole, gli intID validi x soddisfano i valori bassi <= x && x < high.
Se non viene restituito alcun errore, low + n == high.
funzione Elimina
Il tasto Canc elimina l'entità della chiave specificata.
funzione DeleteMulti
DeleteMulti è una versione batch di Delete.
funzione EnableKeyConversion
EnableKeyConversion consente la compatibilità delle chiavi codificate con la libreria client di Cloud Datastore (cloud.google.com/go/datastore). Le chiavi codificate generate dalla libreria client di Cloud Datastore verranno decodificate in chiavi del datastore App Engine.
Il contesto fornito deve essere un contesto App Engine se viene eseguito nel runtime di prima generazione di App Engine. Questa può essere chiamata nel gestore /_ah/start. È sicuro chiamare più volte ed è economico da chiamare, quindi può essere inserito anche come middleware.
L'abilitazione della compatibilità della chiave non influisce sul formato di codifica utilizzato da Key.Encode, espande solo il tipo di chiavi che possono essere decodificate con DecodeKey.
funzione Recupero
L'opzione Get carica l'entità archiviata per k in dst, che deve essere un puntatore struct o implementare PropertyLoadSaver. Se non esiste un'entità di questo tipo per la chiave, Get restituisce ErrNoSuchEntity.
I valori dei campi struct senza corrispondenza dst non vengono modificati e i campi corrispondenti digitati con sezione non vengono reimpostati prima di essere aggiunti. In particolare, si consiglia di passare un puntatore a uno struct con valore zero in ogni chiamata Get.
ErrFieldMismatch viene restituito quando un campo deve essere caricato in un tipo diverso da quello da cui è stato archiviato oppure quando un campo risulta mancante o non esportato nello struct di destinazione. ErrFieldMismatch viene restituito solo se dst è un puntatore struct.
funzione GetMulti
GetMulti è una versione batch di Get.
dst deve essere []S, []*S, []I o []P, per alcuni struct di tipo S, di interfaccia di tipo I o di tipo non puntatore P senza interfaccia, in modo che P o *P implementi PropertyLoadSaver. Se []I, ogni elemento deve essere un dst valido per Get: deve essere un puntatore struct o implementare PropertyLoadSaver.
Nel caso speciale, PropertyList è un tipo non valido per dst, anche se un PropertyList è una porzione di struct. Viene considerato non valido per evitare che venga trasmesso erroneamente quando []PropertyList era previsto.
funzione KindProperties
KindProperties restituisce tutte le proprietà indicizzate per il tipo specificato. Le proprietà vengono restituite come una mappa dei nomi delle proprietà a una sezione dei tipi di rappresentazione. I tipi di rappresentazione per i tipi di proprietà Go supportati sono:
"INT64": signed integers and time.Time
"DOUBLE": float32 and float64
"BOOLEAN": bool
"STRING": string, []byte and ByteString
"POINT": appengine.GeoPoint
"REFERENCE": *Key
"USER": (not used in the Go runtime)
Tipi funzionali
Kinds restituisce i nomi di tutti i tipi nello spazio dei nomi corrente.
LoadStruct funzione
LoadStruct carica le proprietà da p a dst. dst deve essere un puntatore struct.
Spazi dei nomi func
Spazi dei nomi restituisce tutti gli spazi dei nomi del datastore.
funzione RunInTransaction
func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) errorRunInTransaction esegue f in una transazione. Richiama f con un contesto della transazione tc che f dovrebbe utilizzare per tutte le operazioni di App Engine.
Se f restituisce nil, RunInTransaction tenta di eseguire il commit della transazione, restituendo null se l'operazione ha esito positivo. Se il commit non riesce a causa di una transazione in conflitto, RunInTransaction esegue nuovamente l'operazione ogni volta con un nuovo contesto di transazione. Rinuncia e restituisce ErrConcurrentTransaction dopo tre tentativi non riusciti. Il numero di tentativi può essere configurato specificando TransactionOptions.Retry.
Se f restituisce un valore diverso da zero, le modifiche apportate al datastore non verranno applicate e RunInTransaction restituisce lo stesso errore. Non è stato eseguito un nuovo tentativo della funzione f.
Tieni presente che quando viene restituito f, la transazione non è ancora stata confermata. Il codice per la chiamata deve fare attenzione a non presumere che il commit delle modifiche di f sia stato eseguito finché RunInTransaction non restituisce zero.
Poiché f può essere chiamata più volte, di solito dovrebbe essere idempotente. datastore.Get non è idempotente durante l'annullamento del marshalling dei campi sezione.
Le transazioni nidificate non sono supportate; c potrebbe non essere un contesto di transazione.
ByteString
type ByteString []byteByteString è una breve sezione di byte (fino a 1500 byte) che può essere indicizzata.
Cursor
type Cursor struct {
// contains filtered or unexported fields
}Il cursore è la posizione di un iteratore. Può essere convertito da e verso una stringa opaca. Un cursore può essere utilizzato da diverse richieste HTTP, ma solo con una query con lo stesso tipo, predecessore, filtro e vincoli di ordine.
func DecodeCursor
DecodeCursor decodifica un cursore dalla sua rappresentazione della stringa base-64.
Stringa func (Cursore)
La stringa restituisce una rappresentazione stringa base-64 di un cursore.
Entità
Un'entità è il tipo di valore di uno struct nidificato. Questo tipo viene utilizzato solo per il valore di una proprietà.
Mancata corrispondenza campo err
ErrFieldMismatch viene restituito quando un campo deve essere caricato in un tipo diverso da quello da cui è stato archiviato oppure quando un campo risulta mancante o non esportato nello struct di destinazione. StructType è il tipo di struct a cui punta l'argomento di destinazione passato a Get o a Iterator.Next.
Errore funzione (*ErrFieldMismatch)
func (e *ErrFieldMismatch) Error() stringIterator
type Iterator struct {
// contains filtered or unexported fields
}L'iteratore è il risultato dell'esecuzione di una query.
Cursore func (*iteratore)
Il cursore restituisce un cursore per la posizione corrente dell'iteratore.
funzione (*iteratore) Avanti
Quindi restituisce la chiave del risultato successivo. Quando non ci sono altri risultati, viene restituito l'errore "Fine".
Se la query non è solo chiavi e dst non è nullo, carica anche l'entità archiviata per quella chiave nel puntatore struct o PropertyLoadSaver dst, con la stessa semantica e possibili errori della funzione Get.
Chiave
type Key struct {
// contains filtered or unexported fields
}La chiave rappresenta la chiave del datastore per un'entità archiviata ed è immutabile.
func DecodeKey
DecodeKey decodifica una chiave dalla rappresentazione opaca restituita da Encode.
funzione NuovaChiaveIncompleta
NewCOMPLETEKey crea una nuova chiave incompleta. Il tipo non può essere vuoto.
funzione NewKey
NewKey crea una nuova chiave. Il tipo non può essere vuoto. Uno o entrambi gli attributi stringID e intID devono essere pari a zero. Se entrambi i valori sono zero, la chiave restituita è incompleta. La chiave padre deve essere una chiave completa o nulla.
funzione Put
Put salva l'entità src nel datastore con la chiave k. src deve essere un puntatore struct o implementare PropertyLoadSaver; se si tratta di un puntatore struct, tutti i campi non esportati dello struct verranno ignorati. Se k è una chiave incompleta, la chiave restituita sarà una chiave univoca generata dal datastore.
funzione PutMulti
PutMulti è una versione batch di Put.
src deve soddisfare le stesse condizioni dell'argomento dst per GetMulti.
ID app funzione (*Tasto)
AppID restituisce l'ID applicazione della chiave.
func (*Chiave) Codifica
Encode restituisce una rappresentazione opaca della chiave adatta per l'uso in HTML e URL. È compatibile con i runtime Python e Java.
funzione (*Tasto) Uguale
Uguale restituisce se due chiavi sono uguali.
func (*Tasto) GobDecode
funzione (*Chiave) GobEncode
func (*Chiave) Incompleta
Un valore incompleto restituisce se la chiave non fa riferimento a un'entità archiviata. In particolare, indica se la chiave ha un valore StringID pari a zero e un IntID pari a zero.
funzione (*Chiave) IntID
IntID restituisce l'ID intero della chiave, che può essere 0.
func (*Tasto) Tipo
Kind restituisce il tipo di chiave (noto anche come tipo di entità).
funzione (*Chiave) MarshalJSON
Spazio dei nomi func (*Chiave)
Lo spazio dei nomi restituisce lo spazio dei nomi della chiave.
funzione principale (*Tasto)
L'elemento padre restituisce la chiave padre della chiave, che potrebbe essere nulla.
Stringa func (*Key)
La stringa restituisce una rappresentazione stringa della chiave.
ID stringa funzione (*Chiave)
StringID restituisce l'ID stringa della chiave (noto anche come nome entità o nome chiave), che può essere "".
funzione (*Chiave) UnmarshalJSON
Errore KeyRangeCollision
type KeyRangeCollisionError struct {
// contains filtered or unexported fields
}Errore func (*KeyRangeCollisionError)
func (e *KeyRangeCollisionError) Error() stringErrore KeyRangeContentionError
type KeyRangeContentionError struct {
// contains filtered or unexported fields
}Errore func (*KeyRangeContentionError)
func (e *KeyRangeContentionError) Error() stringProprietà
type Property struct {
// Name is the property name.
Name string
// Value is the property value. The valid types are:
// - int64
// - bool
// - string
// - float64
// - ByteString
// - *Key
// - time.Time
// - appengine.BlobKey
// - appengine.GeoPoint
// - []byte (up to 1 megabyte in length)
// - *Entity (representing a nested struct)
// This set is smaller than the set of valid struct field types that the
// datastore can load and save. A Property Value cannot be a slice (apart
// from []byte); use multiple Properties instead. Also, a Value's type
// must be explicitly on the list above; it is not sufficient for the
// underlying type to be on that list. For example, a Value of "type
// myInt64 int64" is invalid. Smaller-width integers and floats are also
// invalid. Again, this is more restrictive than the set of valid struct
// field types.
//
// A Value will have an opaque type when loading entities from an index,
// such as via a projection query. Load entities into a struct instead
// of a PropertyLoadSaver when using a projection query.
//
// A Value may also be the nil interface value; this is equivalent to
// Python's None but not directly representable by a Go struct. Loading
// a nil-valued property into a struct will set that field to the zero
// value.
Value interface{}
// NoIndex is whether the datastore cannot index this property.
NoIndex bool
// Multiple is whether the entity can have multiple properties with
// the same name. Even if a particular instance only has one property with
// a certain name, Multiple should be true if a struct would best represent
// it as a field of type []T instead of type T.
Multiple bool
}La proprietà è una coppia nome/valore più alcuni metadati. I contenuti di un'entità datastore vengono caricati e salvati come sequenza di proprietà. Un'entità può avere più proprietà con lo stesso nome, a condizione che p.Multiple sia true in tutte le proprietà dell'entità con quel nome.
funzione SaveStruct
SaveStruct restituisce le proprietà da src come sezione di Proprietà. L'src deve essere un puntatore struct.
Elenco proprietà
type PropertyList []PropertyPropertyList converte una proprietà []per implementare PropertyLoadSaver.
Caricamento funzione (*PropertyList)
func (l *PropertyList) Load(p []Property) errorIl caricamento carica tutte le proprietà fornite in l. Non reimposta prima *l su una sezione vuota.
func (*PropertyList) Salva
func (l *PropertyList) Save() ([]Property, error)Salva salva tutte le proprietà di l come sezione o proprietà.
Risparmio caricamento proprietà
PropertyLoadSaver può essere convertito da e in una sezione di proprietà.
Query
type Query struct {
// contains filtered or unexported fields
}Query rappresenta una query sul datastore.
funzione NewQuery
NewQuery crea una nuova query per un tipo di entità specifico.
Un tipo vuoto indica di restituire tutte le entità, comprese le entità create e gestite da altre funzionalità di App Engine, e prende il nome di query senza tipo. Le query senza tipo non possono includere filtri o ordinare ordini per i valori delle proprietà.
func (*Query) Antenato
L'antenato restituisce una query derivata con un filtro dei predecessori. Il predecessore non deve essere zero.
funzione (*Query) BatchSize
BatchSize restituisce una query derivata per recuperare contemporaneamente il numero di risultati fornito. Questo valore deve essere maggiore di zero ed uguale o inferiore al limite.
Conteggio funzioni (*query)
Il conteggio restituisce il numero di risultati per la query.
Il tempo di esecuzione e il numero di chiamate API effettuate da Count scalano in modo lineare con la somma dell'offset e del limite della query. A meno che il numero dei risultati non preveda essere basso, è meglio specificare un limite; in caso contrario, il conteggio continuerà fino al termine del conteggio o fino alla scadenza del contesto fornito.
funzione (*Query) Distinta
Distinct restituisce una query derivata che restituisce entità deduplicate rispetto al set di campi previsti. Viene utilizzato solo per le query di proiezione. DistinctOn non può essere utilizzato con DistinctOn.
funzione (*Query) DistinctOn
DistinctOn restituisce una query derivata che restituisce entità deduplicate rispetto al set dei campi specificati. Viene utilizzato solo per le query di proiezione. L'elenco dei campi deve essere un sottoinsieme dell'elenco dei campi previsti. DistinctOn non può essere utilizzato con Distinct.
funzione (*Query) Fine
End restituisce una query derivata con il punto finale specificato.
funzione (*Query) EventualConsistenza
EventualConsistency restituisce una query derivata che restituisce risultati alla fine coerenti. Ha effetto solo sulle query dei predecessori.
Filtro func (*query)
Il filtro restituisce una query derivata con un filtro basato su campi. L'argomento filterStr deve essere un nome di campo seguito da uno spazio facoltativo, seguito da un operatore, uno tra ">", "<", ">=", "<=" o "=". I campi vengono confrontati con il valore fornito utilizzando l'operatore. Più filtri sono collegati tra loro.
funzione (*Query) GetAll
GetAll esegue la query nel contesto specificato e restituisce tutte le chiavi che corrispondono alla query, oltre ad aggiungere i valori a dst.
dst deve avere il tipo []S o *[] S o *[]P, per alcuni struct di tipo S o alcuni struct di tipo S o alcuni senza interfaccia e di tipo P senza puntatori, in modo che P o *P implementi PropertyLoadSaver.
Come caso speciale, *PropertyList è un tipo non valido per dst, anche se un PropertyList è una porzione di struct. Viene considerato non valido per evitare che venga trasmesso erroneamente quando si intendeva un *[]PropertyList.
Le chiavi restituite da GetAll saranno in una corrispondenza 1:1 con le entità aggiunte a dst.
Se q è una query "solo chiavi", GetAll ignora dst e restituisce solo le chiavi.
Il tempo di esecuzione e il numero di chiamate API effettuate da GetAll scalano in modo lineare con la somma dell'offset e del limite della query. A meno che il conteggio dei risultati non preveda essere basso, è meglio specificare un limite; in caso contrario, GetAll continuerà fino a completare la raccolta dei risultati o fino alla scadenza del contesto fornito.
func (*Query) Solo tasti
KeysOnly restituisce una query derivata che restituisce solo chiavi, non chiavi ed entità. Non può essere utilizzato con query di proiezione.
Limite funzioni (*query)
Limite restituisce una query derivata con un limite al numero di risultati restituiti. Un valore negativo significa che è illimitato.
Offset (*query) func
Offset restituisce una query derivata che ha un offset del numero di chiavi da saltare prima di restituire i risultati. Un valore negativo non è valido.
Ordine func (*query)
L'ordine restituisce una query derivata con un ordinamento basato su campi. Gli ordini vengono applicati nell'ordine in cui vengono aggiunti. L'ordine predefinito è crescente; per ordinare in ordine decrescente, fieldName deve essere preceduto da un segno meno (-).
Progetto func (*query)
Il progetto restituisce una query derivata che restituisce solo i campi specificati. Non può essere utilizzato con KeysOnly.
funzione (*query) Esegui
Run esegue la query nel contesto specificato.
funzione (*Query) Inizio
Start restituisce una query derivata con il punto iniziale specificato.
TransactionOptions
type TransactionOptions struct {
// XG is whether the transaction can cross multiple entity groups. In
// comparison, a single group transaction is one where all datastore keys
// used have the same root key. Note that cross group transactions do not
// have the same behavior as single group transactions. In particular, it
// is much more likely to see partially applied transactions in different
// entity groups, in global queries.
// It is valid to set XG to true even if the transaction is within a
// single entity group.
XG bool
// Attempts controls the number of retries to perform when commits fail
// due to a conflicting transaction. If omitted, it defaults to 3.
Attempts int
// ReadOnly controls whether the transaction is a read only transaction.
// Read only transactions are potentially more efficient.
ReadOnly bool
}TransactionOptions sono le opzioni per eseguire una transazione.