TileDB-Go: github.com/TileDB-Inc/TileDB-Go Index | Examples | Files

package tiledb

import "github.com/TileDB-Inc/TileDB-Go"

Package tiledb is a idomatic go binding to tiledb's c_api. Go structs are used for object style access to tiledb types, such as Config and ArraySchema. Tiledb c objects that are alloc'ed are set to be freeded on garbage collection using `runtime.SetFinalizer`.

For more information on TileDB see official docs, https://docs.tiledb.io/en/stable .

Semantic Versioning is followed for this package and for compatibility with upcoming vgo. See compatibility section of Readme for a mapping of TileDB-Go package to tiledb core library versions, https://github.com/TileDB-Inc/TileDB-Go/blob/master/README.md#compatibility .

Installation

See readme for installation requirements and instructions: https://github.com/TileDB-Inc/TileDB-Go/blob/master/README.md#installation .

Quickstart

See quickstart_dense_test.go and quickstart_sparse_test.go for examples. Also checkout the official tiledb quickstart docs https://docs.tiledb.io/en/latest/quickstart.html

ExampleDenseArray shows and example creation, writing and reading of a dense array

Code:

package main

import (
    "fmt"
    "os"

    tiledb "github.com/TileDB-Inc/TileDB-Go"
)

// Name of array.
var denseArrayName = "quickstart_dense"

func createDenseArray() {
    // Create a TileDB context.
    ctx, _ := tiledb.NewContext(nil)

    // The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4].
    domain, _ := tiledb.NewDomain(ctx)
    rowDim, _ := tiledb.NewDimension(ctx, "rows", []int32{1, 4}, int32(4))
    colDim, _ := tiledb.NewDimension(ctx, "cols", []int32{1, 4}, int32(4))
    domain.AddDimensions(rowDim, colDim)

    // The array will be dense.
    schema, _ := tiledb.NewArraySchema(ctx, tiledb.TILEDB_DENSE)
    schema.SetDomain(domain)
    schema.SetCellOrder(tiledb.TILEDB_ROW_MAJOR)
    schema.SetTileOrder(tiledb.TILEDB_ROW_MAJOR)

    // Add a single attribute "a" so each (i,j) cell can store an integer.
    a, _ := tiledb.NewAttribute(ctx, "a", tiledb.TILEDB_INT32)
    schema.AddAttributes(a)

    // Create the (empty) array on disk.
    array, _ := tiledb.NewArray(ctx, denseArrayName)
    array.Create(schema)
}

func writeDenseArray() {
    ctx, _ := tiledb.NewContext(nil)

    // Prepare some data for the array
    data := []int32{
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}

    // Open the array for writing and create the query.
    array, _ := tiledb.NewArray(ctx, denseArrayName)
    array.Open(tiledb.TILEDB_WRITE)
    query, _ := tiledb.NewQuery(ctx, array)
    query.SetLayout(tiledb.TILEDB_ROW_MAJOR)
    query.SetBuffer("a", data)

    // Perform the write and close the array.
    query.Submit()
    array.Close()
}

func readDenseArray() {
    ctx, _ := tiledb.NewContext(nil)

    // Prepare the array for reading
    array, _ := tiledb.NewArray(ctx, denseArrayName)
    array.Open(tiledb.TILEDB_READ)

    // Slice only rows 1, 2 and cols 2, 3, 4
    subArray := []int32{1, 2, 2, 4}

    // Prepare the vector that will hold the result (of size 6 elements)
    data := make([]int32, 6)

    // Prepare the query
    query, _ := tiledb.NewQuery(ctx, array)
    query.SetSubArray(subArray)
    query.SetLayout(tiledb.TILEDB_ROW_MAJOR)
    query.SetBuffer("a", data)

    // Submit the query and close the array.
    query.Submit()
    array.Close()

    // Print out the results.
    fmt.Println(data)
}

// ExampleDenseArray shows and example creation, writing and reading of a dense
// array
func main() {
    createDenseArray()
    writeDenseArray()
    readDenseArray()
    // Output: [2 3 4 6 7 8]

    // Cleanup example so unit tests are clean
    if _, err := os.Stat(denseArrayName); err == nil {
        os.RemoveAll(denseArrayName)
    }
}

ExampleSparseArray shows and example creation, writing and reading of a sparse array

Code:

package main

import (
    "fmt"
    "os"

    tiledb "github.com/TileDB-Inc/TileDB-Go"
)

// Name of array.
var sparseArrayName = "quickstart_sparse"

func createSparseArray() {
    // Create a TileDB context.
    ctx, _ := tiledb.NewContext(nil)

    // The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4].
    domain, _ := tiledb.NewDomain(ctx)
    rowDim, _ := tiledb.NewDimension(ctx, "rows", []int32{1, 4}, int32(4))
    colDim, _ := tiledb.NewDimension(ctx, "cols", []int32{1, 4}, int32(4))
    domain.AddDimensions(rowDim, colDim)

    // The array will be dense.
    schema, _ := tiledb.NewArraySchema(ctx, tiledb.TILEDB_SPARSE)
    schema.SetDomain(domain)
    schema.SetCellOrder(tiledb.TILEDB_ROW_MAJOR)
    schema.SetTileOrder(tiledb.TILEDB_ROW_MAJOR)

    // Add a single attribute "a" so each (i,j) cell can store an integer.
    a, _ := tiledb.NewAttribute(ctx, "a", tiledb.TILEDB_INT32)
    schema.AddAttributes(a)

    // Create the (empty) array on disk.
    array, _ := tiledb.NewArray(ctx, sparseArrayName)
    array.Create(schema)
}

func writeSparseArray() {
    ctx, _ := tiledb.NewContext(nil)

    // Write some simple data to cells (1, 1), (2, 4) and (2, 3).
    coords := []int32{1, 1, 2, 4, 2, 3}
    data := []int32{1, 2, 3}

    // Open the array for writing and create the query.
    array, _ := tiledb.NewArray(ctx, sparseArrayName)
    array.Open(tiledb.TILEDB_WRITE)
    query, _ := tiledb.NewQuery(ctx, array)
    query.SetLayout(tiledb.TILEDB_ROW_MAJOR)
    query.SetBuffer("a", data)
    query.SetCoordinates(coords)

    // Perform the write and close the array.
    query.Submit()
    array.Close()
}

func readSparseArray() {
    ctx, _ := tiledb.NewContext(nil)

    // Prepare the array for reading
    array, _ := tiledb.NewArray(ctx, sparseArrayName)
    array.Open(tiledb.TILEDB_READ)

    // Slice only rows 1, 2 and cols 2, 3, 4
    subArray := []int32{1, 2, 2, 4}

    // Prepare the vector that will hold the results
    // We take the upper bound on the result size as we do not know how large
    // a buffer is needed since the array is sparse
    maxElements, _ := array.MaxBufferElements(subArray)
    data := make([]int32, maxElements["a"][1])
    coords := make([]int32, maxElements[tiledb.TILEDB_COORDS][1])

    // Prepare the query
    query, _ := tiledb.NewQuery(ctx, array)
    query.SetSubArray(subArray)
    query.SetLayout(tiledb.TILEDB_ROW_MAJOR)
    query.SetBuffer("a", data)
    query.SetCoordinates(coords)

    // Submit the query and close the array.
    query.Submit()
    array.Close()

    // Print out the results.
    for r := 0; r < len(data); r++ {
        i := coords[2*r]
        j := coords[2*r+1]
        fmt.Printf("Cell (%d, %d) has data %d\n", i, j, data[r])
    }
}

// ExampleSparseArray shows and example creation, writing and reading of a
// sparse array
func main() {
    createSparseArray()
    writeSparseArray()
    readSparseArray()

    // Output: Cell (2, 3) has data 3
    // Cell (2, 4) has data 2

    // Cleanup example so unit tests are clean
    if _, err := os.Stat(sparseArrayName); err == nil {
        os.RemoveAll(sparseArrayName)
    }
}

Index

Examples

Package Files

array.go array_schema.go attribute.go config.go context.go dimension.go doc.go domain.go enums.go filter.go filter_list.go group.go query.go stats.go version.go vfs.go

Variables

var TILEDB_COORDS = C.GoString(C.TILEDB_COORDS)

TILEDB_COORDS A special name indicating the coordinates attribute.

var TILEDB_VAR_NUM = uint(C.TILEDB_VAR_NUM)

TILEDB_VAR_NUM indicates variable sized attributes for cell values

func GroupCreate Uses

func GroupCreate(context *Context, group string) error

GroupCreate creates a new tiledb group. A Group is a logical grouping of Objects on the storage system (a directory).

Code:

// Create context without config
context, err := NewContext(nil)
if err != nil {
    // Handle error
    return
}

// Create Group
err = GroupCreate(context, "my_group")
if err != nil {
    // Handle error
    return
}

func StatsDisable Uses

func StatsDisable() error

StatsDisable disable internal statistics gathering.

func StatsDump Uses

func StatsDump(path string) error

StatsDump prints internal stats to file path given

func StatsDumpSTDOUT Uses

func StatsDumpSTDOUT() error

StatsDumpSTDOUT prints internal stats to stdout

func StatsEnable Uses

func StatsEnable() error

StatsEnable enable internal statistics gathering

Example usage of tiledb statistics

Code:


err := StatsEnable()
if err != nil {
    // Handle error
}

// Perform tile operations
err = StatsDumpSTDOUT()
if err != nil {
    // Handle error
}

func StatsReset Uses

func StatsReset() error

StatsReset reset all internal statistics counters to 0.

func Version Uses

func Version() (major int, minor int, rev int)

Version returns the TileDB shared library version these bindings are linked against at runtime

Code:

major, minor, rev := Version()
fmt.Printf("TileDB shared library version is %d.%d.%d", major, minor, rev)

type Array Uses

type Array struct {
    // contains filtered or unexported fields
}

Array struct representing a TileDB array object.

An Array object represents array data in TileDB at some persisted location, e.g. on disk, in an S3 bucket, etc. Once an array has been opened for reading or writing, interact with the data through Query objects.

func NewArray Uses

func NewArray(ctx *Context, uri string) (*Array, error)

NewArray alloc a new array

Code:

// Create Config, this is optional
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Create Dimension
dimension, err := NewDimension(context, "test", []int32{1, 10}, 5)
if err != nil {
    // Handle error
    return
}

// Create Domain
domain, err := NewDomain(context)
if err != nil {
    // Handle error
    return
}

// Add dimension to domain
err = domain.AddDimensions(dimension)
if err != nil {
    // Handle error
    return
}

arraySchema, err := NewArraySchema(context, TILEDB_DENSE)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute, err := NewAttribute(context, "a1", TILEDB_INT32)

if err != nil {
    // Handle error
    return
}

err = arraySchema.AddAttributes(attribute)
if err != nil {
    // Handle error
    return
}

array, err := NewArray(context, "my_array")
if err != nil {
    // Handle error
    return
}

err = array.Create(arraySchema)
if err != nil {
    // Handle error
    return
}

func (*Array) Close Uses

func (a *Array) Close() error

Close a tiledb array, this is called on garbage collection automatically

func (*Array) Consolidate Uses

func (a *Array) Consolidate() error

Consolidate Consolidates the fragments of an array into a single fragment. You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

func (*Array) ConsolidateWithKey Uses

func (a *Array) ConsolidateWithKey(encryptionType EncryptionType, key string) error

ConsolidateWithKey Consolidates the fragments of an encrypted array into a single fragment. You must first finalize all queries to the array before consolidation can begin (as consolidation temporarily acquires an exclusive lock on the array).

func (*Array) Create Uses

func (a *Array) Create(arraySchema *ArraySchema) error

Create a new TileDB array given an input schema.

func (*Array) CreateWithKey Uses

func (a *Array) CreateWithKey(arraySchema *ArraySchema, encryptionType EncryptionType, key string) error

CreateWithKey a new TileDB array given an input schema.

func (*Array) Free Uses

func (a *Array) Free()

Free tiledb_array_t that was allocated on heap in c

func (*Array) MaxBufferElements Uses

func (a *Array) MaxBufferElements(subarray interface{}) (map[string][2]uint64, error)

MaxBufferElements compute an upper bound on the buffer elements needed to read a subarray. Returns A map of attribute name (including TILEDB_COORDS) to the maximum number of elements that can be read in the given subarray. For each attribute, a pair of numbers are returned. The first, for variable-length attributes, is the maximum number of offsets for that attribute in the given subarray. For fixed-length attributes and coordinates, the first is always 0. The second is the maximum number of elements for that attribute in the given subarray.

func (*Array) MaxBufferSize Uses

func (a *Array) MaxBufferSize(attributeName string, subarray interface{}) (uint64, error)

MaxBufferSize computes the upper bound on the buffer size (in bytes) required for a read query for a given fixed attribute and subarray

func (*Array) MaxBufferSizeVar Uses

func (a *Array) MaxBufferSizeVar(attributeName string, subarray interface{}) (uint64, uint64, error)

MaxBufferSizeVar computes the upper bound on the buffer size (in bytes) required for a read query for a given variable sized attribute and subarray

func (*Array) NonEmptyDomain Uses

func (a *Array) NonEmptyDomain() ([]map[string]interface{}, bool, error)

NonEmptyDomain retrieves the non-empty domain from an array This returns the bounding coordinates for each dimension

func (*Array) Open Uses

func (a *Array) Open(queryType QueryType) error

Open the array. The array is opened using a query type as input. This is to indicate that queries created for this Array object will inherit the query type. In other words, Array objects are opened to receive only one type of queries. They can always be closed and be re-opened with another query type. Also there may be many different Array objects created and opened with different query types. For instance, one may create and open an array object array_read for reads and another one array_write for writes, and interleave creation and submission of queries for both these array objects.

func (*Array) OpenAt Uses

func (a *Array) OpenAt(queryType QueryType, timestamp uint64) error

OpenAt Similar to tiledb_array_open, but this function takes as input a timestamp, representing time in milliseconds ellapsed since 1970-01-01 00:00:00 +0000 (UTC). Opening the array at a timestamp provides a view of the array with all writes/updates that happened at or before timestamp (i.e., excluding those that occurred after timestamp). This function is useful to ensure consistency at a potential distributed setting, where machines need to operate on the same view of the array.

func (*Array) OpenAtWithKey Uses

func (a *Array) OpenAtWithKey(queryType QueryType, encryptionType EncryptionType, key string, timestamp uint64) error

OpenAtWithKey Similar to tiledb_array_open_with_key, but this function takes as input a timestamp, representing time in milliseconds ellapsed since 1970-01-01 00:00:00 +0000 (UTC). Opening the array at a timestamp provides a view of the array with all writes/updates that happened at or before timestamp (i.e., excluding those that occurred after timestamp). This function is useful to ensure consistency at a potential distributed setting, where machines need to operate on the same view of the array.

func (*Array) OpenWithKey Uses

func (a *Array) OpenWithKey(queryType QueryType, encryptionType EncryptionType, key string) error

OpenWithKey Opens an encrypted array using the given encryption key. This function has the same semantics as tiledb_array_open() but is used for encrypted arrays.

An encrypted array must be opened with this function before queries can be issued to it.

func (*Array) QueryType Uses

func (a *Array) QueryType() (QueryType, error)

QueryType return the current query type of an open array

func (*Array) Reopen Uses

func (a *Array) Reopen() error

Reopen the array (the array must be already open). This is useful when the array got updated after it got opened and the Array object got created. To sync-up with the updates, the user must either close the array and open with open(), or just use reopen() without closing. This function will be generally faster than the former alternative.

func (*Array) Schema Uses

func (a *Array) Schema() (*ArraySchema, error)

Schema returns the ArraySchema for the array

func (*Array) URI Uses

func (a *Array) URI() (string, error)

URI returns the array's uri

type ArraySchema Uses

type ArraySchema struct {
    // contains filtered or unexported fields
}

ArraySchema Schema describing an array.

The schema is an independent description of an array. A schema can be used to create multiple array’s, and stores information about its domain, cell types, and compression details. An array schema is composed of:

A Domain
A set of Attributes
Memory layout definitions: tile and cell
Compression details for Array level factors like offsets and coordinates

func LoadArraySchema Uses

func LoadArraySchema(context *Context, path string) (*ArraySchema, error)

LoadArraySchema reads a directory for a ArraySchema

func LoadArraySchemaWithKey Uses

func LoadArraySchemaWithKey(context *Context, path string, encryptionType EncryptionType, key string) (*ArraySchema, error)

LoadArraySchemaWithKey retrieves the schema of an encrypted array from the disk, creating an array schema struct.

func NewArraySchema Uses

func NewArraySchema(ctx *Context, arrayType ArrayType) (*ArraySchema, error)

NewArraySchema alloc a new ArraySchema

Code:

// Create Config, this is optional
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Create Dimension
dimension, err := NewDimension(context, "test", []int32{1, 10}, 5)
if err != nil {
    // Handle error
    return
}

// Create Domain
domain, err := NewDomain(context)
if err != nil {
    // Handle error
    return
}

// Add dimension to domain
err = domain.AddDimensions(dimension)
if err != nil {
    // Handle error
    return
}

arraySchema, err := NewArraySchema(context, TILEDB_DENSE)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute, err := NewAttribute(context, "a1", TILEDB_INT32)

if err != nil {
    // Handle error
    return
}

err = arraySchema.AddAttributes(attribute)
if err != nil {
    // Handle error
    return
}

func (*ArraySchema) AddAttributes Uses

func (a *ArraySchema) AddAttributes(attributes ...*Attribute) error

AddAttributes add one or more attributes to the array

func (*ArraySchema) AttributeFromIndex Uses

func (a *ArraySchema) AttributeFromIndex(index uint) (*Attribute, error)

AttributeFromIndex get a copy of an Attribute in the schema by name.

func (*ArraySchema) AttributeFromName Uses

func (a *ArraySchema) AttributeFromName(attrName string) (*Attribute, error)

AttributeFromName Get a copy of an Attribute in the schema by index. Attributes are ordered the same way they were defined when constructing the array schema.

func (*ArraySchema) AttributeNum Uses

func (a *ArraySchema) AttributeNum() (uint, error)

AttributeNum returns the number of attributes

func (*ArraySchema) Attributes Uses

func (a *ArraySchema) Attributes() ([]*Attribute, error)

Attributes gets all attributes in the array.

func (*ArraySchema) Capacity Uses

func (a *ArraySchema) Capacity() (uint64, error)

Capacity returns the tile capacity.

func (*ArraySchema) CellOrder Uses

func (a *ArraySchema) CellOrder() (Layout, error)

CellOrder return the cell order

func (*ArraySchema) Check Uses

func (a *ArraySchema) Check() error

Check validates the schema

func (*ArraySchema) CoordsFilterList Uses

func (a *ArraySchema) CoordsFilterList() (*FilterList, error)

CoordsFilterList Returns a copy of the filter list of the coordinates.

func (*ArraySchema) Domain Uses

func (a *ArraySchema) Domain() (*Domain, error)

Domain returns the array's domain

func (*ArraySchema) Dump Uses

func (a *ArraySchema) Dump(path string) error

Dump Dumps the array schema in ASCII format in the selected output.

func (*ArraySchema) DumpSTDOUT Uses

func (a *ArraySchema) DumpSTDOUT() error

DumpSTDOUT Dumps the array schema in ASCII format to stdout

func (*ArraySchema) Free Uses

func (a *ArraySchema) Free()

Free tiledb_array_schema_t that was allocated on heap in c

func (*ArraySchema) OffsetsFilterList Uses

func (a *ArraySchema) OffsetsFilterList() (*FilterList, error)

OffsetsFilterList returns a copy of the FilterList of the offsets for variable-length attributes.

func (*ArraySchema) SetCapacity Uses

func (a *ArraySchema) SetCapacity(capacity uint64) error

SetCapacity sets the tile capacity.

func (*ArraySchema) SetCellOrder Uses

func (a *ArraySchema) SetCellOrder(cellOrder Layout) error

SetCellOrder set the cell order

func (*ArraySchema) SetCoordsFilterList Uses

func (a *ArraySchema) SetCoordsFilterList(filterList *FilterList) error

SetCoordsFilterList sets the filter list used for coordinates

func (*ArraySchema) SetDomain Uses

func (a *ArraySchema) SetDomain(domain *Domain) error

SetDomain sets the array domain

func (*ArraySchema) SetOffsetsFilterList Uses

func (a *ArraySchema) SetOffsetsFilterList(filterList *FilterList) error

SetOffsetsFilterList sets the filter list for the offsets of variable-length attributes

func (*ArraySchema) SetTileOrder Uses

func (a *ArraySchema) SetTileOrder(tileOrder Layout) error

SetTileOrder set the tile order

func (*ArraySchema) TileOrder Uses

func (a *ArraySchema) TileOrder() (Layout, error)

TileOrder return the tile order

type ArrayType Uses

type ArrayType int8

ArrayType enum for tiledb arrays

const (
    // TILEDB_DENSE dense array
    TILEDB_DENSE ArrayType = C.TILEDB_DENSE
    // TILEDB_SPARSE dense array
    TILEDB_SPARSE ArrayType = C.TILEDB_SPARSE
)

type Attribute Uses

type Attribute struct {
    // contains filtered or unexported fields
}

Attribute describes an attribute of an Array cell.

An attribute specifies a name and datatype for a particular value in each array cell. There are 3 supported attribute types:

Fundamental types, such as char, int, double, uint64, etc..
Fixed sized arrays: [N]T or make([]T, N), where T is a fundamental type
Variable length data: string, []T, where T is a fundamental type

func NewAttribute Uses

func NewAttribute(context *Context, name string, datatype Datatype) (*Attribute, error)

NewAttribute alloc a new attribute

Code:

// Create Config, this is optional
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Create Attribute
attribute, err := NewAttribute(context, "test", TILEDB_INT32)
if err != nil {
    // Handle error
    return
}

// Set Filter List
filter, err := NewFilter(context, TILEDB_FILTER_GZIP)
if err != nil {
    // Handle error
    return
}
filterList, err := NewFilterList(context)
if err != nil {
    // Handle error
    return
}
err = filterList.AddFilter(filter)
if err != nil {
    // Handle error
    return
}
err = attribute.SetFilterList(filterList)
if err != nil {
    // Handle error
    return
}

// Set Cell Value Number
err = attribute.SetCellValNum(10)
if err != nil {
    // Handle error
    return
}

func (*Attribute) CellValNum Uses

func (a *Attribute) CellValNum() (uint, error)

CellValNum returns number of values of one cell on this attribute. For variable-sized attributes returns TILEDB_VAR_NUM.

func (*Attribute) Dump Uses

func (a *Attribute) Dump(path string) error

Dump Dumps the attribute in ASCII format in the selected output.

func (*Attribute) DumpSTDOUT Uses

func (a *Attribute) DumpSTDOUT() error

DumpSTDOUT Dumps the attribute in ASCII format to stdout

func (*Attribute) FilterList Uses

func (a *Attribute) FilterList() (*FilterList, error)

FilterList returns a copy of the filter list for attribute

func (*Attribute) Free Uses

func (a *Attribute) Free()

Free tiledb_attribute_t that was allocated on heap in c

func (*Attribute) Name Uses

func (a *Attribute) Name() (string, error)

Name returns name of attribute

func (*Attribute) SetCellValNum Uses

func (a *Attribute) SetCellValNum(val uint) error

SetCellValNum Sets the number of attribute values per cell. This is inferred from the type parameter of the NewAttribute function, but can also be set manually.

func (*Attribute) SetFilterList Uses

func (a *Attribute) SetFilterList(filterlist *FilterList) error

SetFilterList sets the attribute filterList

Code:

// Create configuration
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

attribute, err := NewAttribute(context, "test", TILEDB_INT32)
if err != nil {
    // Handle error
    return
}
// Set Filter List
filter, err := NewFilter(context, TILEDB_FILTER_GZIP)
if err != nil {
    // Handle error
    return
}

err = filter.SetOption(TILEDB_COMPRESSION_LEVEL, int32(5))
if err != nil {
    // Handle error
    return
}

filterList, err := NewFilterList(context)
if err != nil {
    // Handle error
    return
}
err = filterList.AddFilter(filter)
if err != nil {
    // Handle error
    return
}
err = attribute.SetFilterList(filterList)
if err != nil {
    // Handle error
    return
}

func (*Attribute) Type Uses

func (a *Attribute) Type() (Datatype, error)

Type returns the attribute datatype

type Config Uses

type Config struct {
    // contains filtered or unexported fields
}

Config Carries configuration parameters for a context.

func LoadConfig Uses

func LoadConfig(uri string) (*Config, error)

LoadConfig reads a configuration from a given uri

func NewConfig Uses

func NewConfig() (*Config, error)

NewConfig alloc a new configuration

func (*Config) Free Uses

func (c *Config) Free()

Free tiledb_config_t that was allocated on heap in c

func (*Config) Get Uses

func (c *Config) Get(param string) (string, error)

Get Get a parameter from the configuration by key.

Code:

config, err := NewConfig()
if err != nil {
    // handle error
}

val, err := config.Get("sm.tile_cache_size")
if err != nil {
    // handle error
}
fmt.Println(val)

Output:

10000000

func (*Config) SaveToFile Uses

func (c *Config) SaveToFile(file string) error

SaveToFile Saves the config parameters to a (local) text file.

func (*Config) Set Uses

func (c *Config) Set(param string, value string) error

Set Sets a config parameter-value pair.

Code:

config, err := NewConfig()
if err != nil {
    // handle error
}

err = config.Set("sm.tile_cache_size", "10")
if err != nil {
    // handle error
}

val, err := config.Get("sm.tile_cache_size")
if err != nil {
    // handle error
}
fmt.Println(val)

Output:

10

func (*Config) Unset Uses

func (c *Config) Unset(param string) error

Unset Resets a config parameter to its default value.

type Context Uses

type Context struct {
    // contains filtered or unexported fields
}

Context A TileDB context wraps a TileDB storage manager “instance.” Most objects and functions will require a Context. Internal error handling is also defined by the Context; the default error handler throws a TileDBError with a specific message.

func NewContext Uses

func NewContext(config *Config) (*Context, error)

NewContext creates a TileDB context with the given configuration If the configuration passed is null it is created with default config

ExampleNewContext example of creating a new context

Code:

// Create Context with default configuration
context, err := NewContext(nil)

if err != nil {
    // handle error
    return
}

// Create a config
config, err := NewConfig()
if err != nil {
    // handle error
    return
}

// Use created config to create a new Context
context, err = NewContext(config)
if err != nil {
    // handle error
    return
}

// Check if S3 is supported
isS3Supported, err := context.IsSupportedFS(TILEDB_S3)
if err != nil {
    // handle error
    return
}

Output:

false

func (*Context) Config Uses

func (c *Context) Config() (*Config, error)

Config retrieves a copy of the config from context

func (*Context) Free Uses

func (c *Context) Free()

Free tiledb_ctx_t that was allocated on heap in c

func (*Context) IsSupportedFS Uses

func (c *Context) IsSupportedFS(fs FS) (bool, error)

IsSupportedFS Return true if the given filesystem backend is supported.

func (*Context) LastError Uses

func (c *Context) LastError() error

LastError returns the last error from this context

type Datatype Uses

type Datatype int8

Datatype

const (
    // TILEDB_INT32 32-bit signed integer
    TILEDB_INT32 Datatype = C.TILEDB_INT32
    // TILEDB_INT64 64-bit signed integer
    TILEDB_INT64 Datatype = C.TILEDB_INT64
    // TILEDB_FLOAT32 32-bit floating point value
    TILEDB_FLOAT32 Datatype = C.TILEDB_FLOAT32
    // TILEDB_FLOAT64 64-bit floating point value
    TILEDB_FLOAT64 Datatype = C.TILEDB_FLOAT64
    // TILEDB_CHAR Character
    TILEDB_CHAR Datatype = C.TILEDB_CHAR
    // TILEDB_INT8 8-bit signed integer
    TILEDB_INT8 Datatype = C.TILEDB_INT8
    // TILEDB_UINT8 8-bit unsigned integer
    TILEDB_UINT8 Datatype = C.TILEDB_UINT8
    // TILEDB_INT16 16-bit signed integer
    TILEDB_INT16 Datatype = C.TILEDB_INT16
    // TILEDB_UINT16 16-bit unsigned integer
    TILEDB_UINT16 Datatype = C.TILEDB_UINT16
    // TILEDB_UINT32 32-bit unsigned integer
    TILEDB_UINT32 Datatype = C.TILEDB_UINT32
    // TILEDB_UINT64 64-bit unsigned integer
    TILEDB_UINT64 Datatype = C.TILEDB_UINT64
    // TILEDB_STRING_ASCII ASCII string
    TILEDB_STRING_ASCII Datatype = C.TILEDB_STRING_ASCII
    // TILEDB_STRING_UTF8 UTF-8 string
    TILEDB_STRING_UTF8 Datatype = C.TILEDB_STRING_UTF8
    // TILEDB_STRING_UTF16 UTF-16 string
    TILEDB_STRING_UTF16 Datatype = C.TILEDB_STRING_UTF16
    // TILEDB_STRING_UTF32 UTF-32 string
    TILEDB_STRING_UTF32 Datatype = C.TILEDB_STRING_UTF32
    // TILEDB_STRING_UCS2 UCS2 string
    TILEDB_STRING_UCS2 Datatype = C.TILEDB_STRING_UCS2
    // TILEDB_STRING_UCS4 UCS4 string
    TILEDB_STRING_UCS4 Datatype = C.TILEDB_STRING_UCS4
    // TILEDB_ANY This can be any datatype. Must store (type tag, value) pairs.
    TILEDB_ANY Datatype = C.TILEDB_ANY
)

func (Datatype) ReflectKind Uses

func (d Datatype) ReflectKind() reflect.Kind

ReflectKind returns the reflect kind given a datatype

type Dimension Uses

type Dimension struct {
    // contains filtered or unexported fields
}

Dimension Describes one dimension of an Array. The dimension consists of a type, lower and upper bound, and tile-extent describing the memory ordering. Dimensions are added to a Domain.

func NewDimension Uses

func NewDimension(context *Context, name string, domain interface{}, extent interface{}) (*Dimension, error)

NewDimension alloc a new dimension

Code:

// Create Config, this is optional
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Create Dimension
_, err = NewDimension(context, "test", []int32{1, 10}, int32(5))
if err != nil {
    // Handle error
    return
}

func (*Dimension) Domain Uses

func (d *Dimension) Domain() (interface{}, error)

Domain returns the dimension's domain

func (*Dimension) Dump Uses

func (d *Dimension) Dump(path string) error

Dump Dumps the dimension in ASCII format in the selected output.

func (*Dimension) DumpSTDOUT Uses

func (d *Dimension) DumpSTDOUT() error

DumpSTDOUT Dumps the dimension in ASCII format to stdout

func (*Dimension) Extent Uses

func (d *Dimension) Extent() (interface{}, error)

Extent returns the dimension's extent

func (*Dimension) Free Uses

func (d *Dimension) Free()

Free tiledb_dimension_t that was allocated on heap in c

func (*Dimension) Name Uses

func (d *Dimension) Name() (string, error)

Name returns the name of the dimension

func (*Dimension) Type Uses

func (d *Dimension) Type() (Datatype, error)

Type returns the type of the dimension

type Domain Uses

type Domain struct {
    // contains filtered or unexported fields
}

Domain Represents the domain of an array. A Domain defines the set of Dimension objects for a given array. The properties of a Domain derive from the underlying dimensions. A Domain is a component of an ArraySchema.

func NewDomain Uses

func NewDomain(ctx *Context) (*Domain, error)

NewDomain alloc a new domainuration

Code:

// Create Config, this is optional
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Create Dimension
dimension, err := NewDimension(context, "test", []int32{1, 10}, int32(5))
if err != nil {
    // Handle error
    return
}

// Create Domain
domain, err := NewDomain(context)
if err != nil {
    // Handle error
    return
}

// Add dimension to domain
err = domain.AddDimensions(dimension)
if err != nil {
    // Handle error
    return
}

func (*Domain) AddDimensions Uses

func (d *Domain) AddDimensions(dimensions ...*Dimension) error

AddDimensions adds one or more dimensions to a domain

func (*Domain) DimensionFromIndex Uses

func (d *Domain) DimensionFromIndex(index uint) (*Dimension, error)

DimensionFromIndex retrieves a dimension object from a domain by index.

func (*Domain) DimensionFromName Uses

func (d *Domain) DimensionFromName(name string) (*Dimension, error)

DimensionFromName retrieves a dimension object from a domain by name (key)

func (*Domain) Dump Uses

func (d *Domain) Dump(path string) error

Dump Dumps the domain in ASCII format in the selected output.

func (*Domain) DumpSTDOUT Uses

func (d *Domain) DumpSTDOUT() error

DumpSTDOUT Dumps the domain in ASCII format to stdout

func (*Domain) Free Uses

func (d *Domain) Free()

Free tiledb_domain_t that was allocated on heap in c

func (*Domain) NDim Uses

func (d *Domain) NDim() (uint, error)

NDim returns the number of dimensions

func (*Domain) Type Uses

func (d *Domain) Type() (Datatype, error)

Type returns a domains type deduced from dimensions

type EncryptionType Uses

type EncryptionType uint8

EncryptionType represents different encryption algorithms

const (
    // TILEDB_NO_ENCRYPTION No encryption
    TILEDB_NO_ENCRYPTION EncryptionType = C.TILEDB_NO_ENCRYPTION
    // TILEDB_AES_256_GCM AES-256-GCM encryption
    TILEDB_AES_256_GCM EncryptionType = C.TILEDB_AES_256_GCM
)

type FS Uses

type FS int8

FS represents support fs types

const (
    // TILEDB_HDFS HDFS filesystem support
    TILEDB_HDFS FS  = C.TILEDB_HDFS

    // TILEDB_S3 S3 filesystem support
    TILEDB_S3 FS  = C.TILEDB_S3
)

type Filter Uses

type Filter struct {
    // contains filtered or unexported fields
}

Filter represents

func NewFilter Uses

func NewFilter(context *Context, filterType FilterType) (*Filter, error)

NewFilter Allocs a new filter

func (*Filter) Free Uses

func (f *Filter) Free()

Free c-alloc'ed data types

func (*Filter) Option Uses

func (f *Filter) Option(filterOption FilterOption) (interface{}, error)

Option fetchs the specified option set on a filter. Returns an interface{} dependent on the option being fetched var optionValue int32 optionValueInterface, err := filter.Option(TILEDB_FILTER_GZIP) optionValue = optionValueInterface.(int32)

func (*Filter) SetOption Uses

func (f *Filter) SetOption(filterOption FilterOption, valueInterface interface{}) error

SetOption set an option on a filter. Options are filter dependent; this function returns an error if the given option is not valid for the given filter.

func (*Filter) Type Uses

func (f *Filter) Type() (FilterType, error)

Type returns the filter type

type FilterList Uses

type FilterList struct {
    // contains filtered or unexported fields
}

FilterList represents

func NewFilterList Uses

func NewFilterList(context *Context) (*FilterList, error)

Alloc a new FilterList

func (*FilterList) AddFilter Uses

func (f *FilterList) AddFilter(filter *Filter) error

AddFilter appends a filter to a filter list. Data is processed through each filter in the order the filters were added.

func (*FilterList) FilterFromIndex Uses

func (f *FilterList) FilterFromIndex(index uint32) (*Filter, error)

FilterFromIndex Retrieves a filter object from a filter list by index.

func (*FilterList) Filters Uses

func (f *FilterList) Filters() ([]*Filter, error)

Filters return slice of filters applied to filter list

func (*FilterList) Free Uses

func (f *FilterList) Free()

Free c-alloc'ed data types

func (*FilterList) MaxChunkSize Uses

func (f *FilterList) MaxChunkSize() (uint32, error)

MaxChunkSize Gets the maximum tile chunk size for a filter list.

func (*FilterList) NFilters Uses

func (f *FilterList) NFilters() (uint32, error)

NFilters Retrieves the number of filters in a filter list.

func (*FilterList) SetMaxChunkSize Uses

func (f *FilterList) SetMaxChunkSize(maxChunkSize uint32) error

SetMaxChunkSize sets the maximum tile chunk size for a filter list.

type FilterOption Uses

type FilterOption uint8

FilterOption for a given filter

const (
    // TILEDB_COMPRESSION_LEVEL Compression level. Type: `int32_t`.
    TILEDB_COMPRESSION_LEVEL FilterOption = C.TILEDB_COMPRESSION_LEVEL
    // TILEDB_BIT_WIDTH_MAX_WINDOW Max window length for bit width reduction. Type: `uint32_t`.
    TILEDB_BIT_WIDTH_MAX_WINDOW FilterOption = C.TILEDB_BIT_WIDTH_MAX_WINDOW
    // TILEDB_POSITIVE_DELTA_MAX_WINDOW Max window length for positive-delta encoding. Type: `uint32_t`.
    TILEDB_POSITIVE_DELTA_MAX_WINDOW FilterOption = C.TILEDB_POSITIVE_DELTA_MAX_WINDOW
)

type FilterType Uses

type FilterType uint8

FilterType for attribute/coordinates/offsets filters

const (
    // TILEDB_FILTER_NONE No-op filter
    TILEDB_FILTER_NONE FilterType = C.TILEDB_FILTER_NONE
    // TILEDB_FILTER_GZIP Gzip compressor
    TILEDB_FILTER_GZIP FilterType = C.TILEDB_FILTER_GZIP
    // TILEDB_FILTER_ZSTD Zstandard compressor
    TILEDB_FILTER_ZSTD FilterType = C.TILEDB_FILTER_ZSTD
    // TILEDB_FILTER_LZ4 LZ4 compressor
    TILEDB_FILTER_LZ4 FilterType = C.TILEDB_FILTER_LZ4
    // TILEDB_FILTER_RLE Run-length encoding compressor
    TILEDB_FILTER_RLE FilterType = C.TILEDB_FILTER_RLE
    // TILEDB_FILTER_BZIP2 Bzip2 compressor
    TILEDB_FILTER_BZIP2 FilterType = C.TILEDB_FILTER_BZIP2
    // TILEDB_FILTER_DOUBLE_DELTA Double-delta compressor
    TILEDB_FILTER_DOUBLE_DELTA FilterType = C.TILEDB_FILTER_DOUBLE_DELTA
    // TILEDB_FILTER_BIT_WIDTH_REDUCTION Bit width reduction filter.
    TILEDB_FILTER_BIT_WIDTH_REDUCTION FilterType = C.TILEDB_FILTER_BIT_WIDTH_REDUCTION
    // TILEDB_FILTER_BITSHUFFLE Bitshuffle filter.
    TILEDB_FILTER_BITSHUFFLE FilterType = C.TILEDB_FILTER_BITSHUFFLE
    // TILEDB_FILTER_BYTESHUFFLE Byteshuffle filter.
    TILEDB_FILTER_BYTESHUFFLE FilterType = C.TILEDB_FILTER_BYTESHUFFLE
    // TILEDB_FILTER_POSITIVE_DELTA Positive-delta encoding filter.
    TILEDB_FILTER_POSITIVE_DELTA FilterType = C.TILEDB_FILTER_POSITIVE_DELTA
)

type Layout Uses

type Layout int8

Layout cell/tile layout

const (
    // TILEDB_ROW_MAJOR Row-major layout
    TILEDB_ROW_MAJOR Layout = C.TILEDB_ROW_MAJOR
    // TILEDB_COL_MAJOR Column-major layout
    TILEDB_COL_MAJOR Layout = C.TILEDB_COL_MAJOR
    // TILEDB_GLOBAL_ORDER Global-order layout
    TILEDB_GLOBAL_ORDER Layout = C.TILEDB_GLOBAL_ORDER
    // TILEDB_UNORDERED Unordered layout
    TILEDB_UNORDERED Layout = C.TILEDB_UNORDERED
)

type Query Uses

type Query struct {
    // contains filtered or unexported fields
}

Query construct and exeute read/write queries on a tiledb Array

func NewQuery Uses

func NewQuery(ctx *Context, array *Array) (*Query, error)

NewQuery Creates a TileDB query object.

The query type (read or write) must be the same as the type used to open the array object.

The storage manager also acquires a shared lock on the array. This means multiple read and write queries to the same array can be made concurrently (in TileDB, only consolidation requires an exclusive lock for a short period of time).

ExampleNewQuery shows a complete write and read example

Code:

// Create configuration
config, err := NewConfig()
if err != nil {
    // Handle error
    return
}

// Test context with config
context, err := NewContext(config)
if err != nil {
    // Handle error
    return
}

// Test create dimension
dimension, err := NewDimension(context, "dim1", []int8{0, 9}, int8(10))
if err != nil {
    // Handle error
    return
}

// Test creating domain
domain, err := NewDomain(context)
if err != nil {
    // Handle error
    return
}

// Add dimension
err = domain.AddDimensions(dimension)
if err != nil {
    // Handle error
    return
}

// Create array schema
arraySchema, err := NewArraySchema(context, TILEDB_DENSE)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute, err := NewAttribute(context, "a1", TILEDB_INT32)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute2, err := NewAttribute(context, "a2", TILEDB_STRING_ASCII)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute3, err := NewAttribute(context, "a3", TILEDB_FLOAT32)
if err != nil {
    // Handle error
    return
}

// Crete attribute to add to schema
attribute4, err := NewAttribute(context, "a4", TILEDB_STRING_UTF8)
if err != nil {
    // Handle error
    return
}

// Set a3 to be variable length
err = attribute3.SetCellValNum(TILEDB_VAR_NUM)
if err != nil {
    // Handle error
    return
}

// Set a4 to be variable length
err = attribute4.SetCellValNum(TILEDB_VAR_NUM)
if err != nil {
    // Handle error
    return
}

// Add Attribute
err = arraySchema.AddAttributes(attribute, attribute2, attribute3, attribute4)
if err != nil {
    // Handle error
    return
}

// Set Domain
err = arraySchema.SetDomain(domain)
if err != nil {
    // Handle error
    return
}

// Validate Schema
err = arraySchema.Check()
if err != nil {
    // Handle error
    return
}

// create temp array name and path
// normal usage would be "my_array" uri
// Temp path is used here so unit test can clean up after itself
tmpArrayPath := os.TempDir() + string(os.PathSeparator) + "tiledb_test_array"
// Cleanup group when test ends
defer os.RemoveAll(tmpArrayPath)
if _, err = os.Stat(tmpArrayPath); err == nil {
    os.RemoveAll(tmpArrayPath)
}
// Create new array struct
array, err := NewArray(context, tmpArrayPath)
if err != nil {
    // Handle error
    return
}

// Create array on disk
err = array.Create(arraySchema)
if err != nil {
    // Handle error
    return
}

// Open array for writting
err = array.Open(TILEDB_WRITE)
if err != nil {
    // Handle error
    return
}

// Create write query
query, err := NewQuery(context, array)
if err != nil {
    // Handle error
    return
}

// Limit writting to subarray
err = query.SetSubArray([]int8{0, 1})
if err != nil {
    // Handle error
    return
}

// Set write layout
err = query.SetLayout(TILEDB_ROW_MAJOR)
if err != nil {
    // Handle error
    return
}

// Create write buffers
bufferA1 := []int32{1, 2}
err = query.SetBuffer("a1", bufferA1)
if err != nil {
    // Handle error
    return
}

bufferA2 := []byte("ab")
err = query.SetBuffer("a2", bufferA2)
if err != nil {
    // Handle error
    return
}

bufferA3 := []float32{1.0, 2.0, 3.0, 4.0, 5.0}
offsetBufferA3 := []uint64{0, 3}
err = query.SetBufferVar("a3", offsetBufferA3, bufferA3)
if err != nil {
    // Handle error
    return
}

bufferA4 := []byte("hello" + "world")
offsetBufferA4 := []uint64{0, 5}
err = query.SetBufferVar("a4", offsetBufferA4, bufferA4)
if err != nil {
    // Handle error
    return
}

err = query.Submit()
if err != nil {
    // Handle error
    return
}

// Validate status, since query was used this is should be complete
status, err := query.Status()
if err != nil {
    // Handle error
    return
}
if status != TILEDB_COMPLETED {
    // handle non-complete query
    // If applicable read partial data in buffer
    // and re-submit for remaining results
}

// Finalize Write
err = query.Finalize()
if err != nil {
    // Handle error
    return
}

// Close and prepare to read
err = array.Close()
if err != nil {
    // Handle error
    return
}

// Reopen array for reading
err = array.Open(TILEDB_READ)
if err != nil {
    // Handle error
    return
}

// Create query for reading
query, err = NewQuery(context, array)
if err != nil {
    // Handle error
    return
}

// Set read subarray to only data that was written
err = query.SetSubArray([]int8{0, 1})
if err != nil {
    // Handle error
    return
}

// Set empty buffers for reading
readBufferA1 := make([]int32, 2)
err = query.SetBuffer("a1", readBufferA1)
if err != nil {
    // Handle error
    return
}

readBufferA2 := make([]byte, 2)
err = query.SetBuffer("a2", readBufferA2)
if err != nil {
    // Handle error
    return
}

readBufferA3 := make([]float32, 5)
readOffsetBufferA3 := make([]uint64, 2)
err = query.SetBufferVar("a3", readOffsetBufferA3, readBufferA3)
if err != nil {
    // Handle error
    return
}
readBufferA4 := make([]byte, 10)
readOffsetBufferA4 := make([]uint64, 2)
err = query.SetBufferVar("a4", readOffsetBufferA4, readBufferA4)
if err != nil {
    // Handle error
    return
}
// Set read layout
err = query.SetLayout(TILEDB_ROW_MAJOR)
if err != nil {
    // Handle error
    return
}
// Submit read query async
// Async submits do not block
err = query.SubmitAsync()
if err != nil {
    // Handle error
    return
}
// Wait for status to return complete or to error
// Loop while status is inprogress
for status, err = query.Status(); status == TILEDB_INPROGRESS && err == nil; status, err = query.Status() {
    // Do something while query is running
}
if err != nil {
    // Handle error
    return
}

// Results should be returned
hasResults, err := query.HasResults()
if err != nil {
    // Handle error
    return
}
if hasResults {
    // Do something with read buffer
}

func (*Query) Buffer Uses

func (q *Query) Buffer(attributeName string) (interface{}, error)

Buffer returns a slice backed by the underlying c buffer from tiledb

func (*Query) BufferVar Uses

func (q *Query) BufferVar(attributeName string) ([]uint64, interface{}, error)

BufferVar returns a slice backed by the underlying c buffer from tiledb for offets and values

func (*Query) Finalize Uses

func (q *Query) Finalize() error

Finalize Flushes all internal state of a query object and finalizes the query. This is applicable only to global layout writes. It has no effect for any other query type.

func (*Query) Free Uses

func (q *Query) Free()

Free tiledb_query_t that was allocated on heap in c

func (*Query) HasResults Uses

func (q *Query) HasResults() (bool, error)

HasResults Returns true if the query has results Applicable only to read queries (it returns false for write queries)

func (*Query) SetBuffer Uses

func (q *Query) SetBuffer(attribute string, buffer interface{}) error

SetBuffer Sets the buffer for a fixed-sized attribute to a query The buffer must be an initialized slice

func (*Query) SetBufferVar Uses

func (q *Query) SetBufferVar(attribute string, offset []uint64, buffer interface{}) error

SetBufferVar Sets the buffer for a fixed-sized attribute to a query The buffer must be an initialized slice

func (*Query) SetCoordinates Uses

func (q *Query) SetCoordinates(coordinates interface{}) error

SetCoordinates sets the coordinate buffer

func (*Query) SetLayout Uses

func (q *Query) SetLayout(layout Layout) error

SetLayout sets the layout of the cells to be written or read

func (*Query) SetSubArray Uses

func (q *Query) SetSubArray(subArray interface{}) error

SetSubArray Sets a subarray, defined in the order dimensions were added. Coordinates are inclusive. For the case of writes, this is meaningful only for dense arrays, and specifically dense writes.

func (*Query) Status Uses

func (q *Query) Status() (QueryStatus, error)

Status returns the status of a query

func (*Query) Submit Uses

func (q *Query) Submit() error

Submit a TileDB query This will block until query is completed

Note: Finalize() must be invoked after finish writing in global layout (via repeated invocations of Submit()), in order to flush any internal state. For the case of reads, if the returned status is TILEDB_INCOMPLETE, TileDB could not fit the entire result in the user’s buffers. In this case, the user should consume the read results (if any), optionally reset the buffers with SetBuffer(), and then resubmit the query until the status becomes TILEDB_COMPLETED. If all buffer sizes after the termination of this function become 0, then this means that no useful data was read into the buffers, implying that the larger buffers are needed for the query to proceed. In this case, the users must reallocate their buffers (increasing their size), reset the buffers with set_buffer(), and resubmit the query.

func (*Query) SubmitAsync Uses

func (q *Query) SubmitAsync() error

SubmitAsync a TileDB query

Async does not currently support the callback function parameter To monitor progress of a query in a non blocking manner the status can be polled:

// Start goroutine for background monitoring
go func(query Query) {
 var status QueryStatus
 var err error
  for status, err = query.Status(); status == TILEDB_INPROGRESS && err == nil; status, err = query.Status() {
    // Do something while query is running
  }
  // Do something when query is finished
}(query)

func (*Query) Type Uses

func (q *Query) Type() (QueryType, error)

Type returns the query type

type QueryStatus Uses

type QueryStatus int8

QueryStatus status of a query

const (
    // TILEDB_FAILED Query failed
    TILEDB_FAILED QueryStatus = C.TILEDB_FAILED
    // TILEDB_COMPLETED Query completed (all data has been read)
    TILEDB_COMPLETED QueryStatus = C.TILEDB_COMPLETED
    // TILEDB_INPROGRESS Query is in progress
    TILEDB_INPROGRESS QueryStatus = C.TILEDB_INPROGRESS
    //TILEDB_INCOMPLETE Query completed (but not all data has been read)
    TILEDB_INCOMPLETE QueryStatus = C.TILEDB_INCOMPLETE
    // TILEDB_UNINITIALIZED Query not initialized.
    TILEDB_UNINITIALIZED QueryStatus = C.TILEDB_UNINITIALIZED
)

type QueryType Uses

type QueryType int8

QueryType read or write query

const (
    // TILEDB_READ Read query
    TILEDB_READ QueryType = C.TILEDB_READ
    // TILEDB_WRITE Write query
    TILEDB_WRITE QueryType = C.TILEDB_WRITE
)

type VFS Uses

type VFS struct {
    // contains filtered or unexported fields
}

VFS Implements a virtual filesystem that enables performing directory/file operations with a unified API on different filesystems, such as local posix/windows, HDFS, AWS S3, etc.

func NewVFS Uses

func NewVFS(context *Context, config *Config) (*VFS, error)

NewVFS alloc a new context using tiledb_vfs_alloc. This also registers the `runtime.SetFinalizer` for handling the free'ing of the c data structure on garbage collection

ExampleNewVFS show basic usage of tiledb's vfs functionality

Code:

// Create a new config
config, err := NewConfig()
if err != nil {
    // return err
}
// Optionally set config settings here
// config.Set("key", "value")

// Create a context
context, err := NewContext(config)
if err != nil {
    // return err
}

// Create a VFS instance
vfs, err := NewVFS(context, config)
if err != nil {
    // return err
}

uri := "file:///tmp/tiledb_example_folder"
// Check if directory exists
if isDir, err := vfs.IsDir(uri); err != nil {
    fmt.Println(err)
} else {
    // Directory exists
    if isDir {
        fmt.Println("URI is a directory")

Output:

URI is not a directory

func (*VFS) Close Uses

func (v *VFS) Close(fh *VFSfh) error

Close a file. This is flushes the buffered data into the file when the file was opened in write (or append) mode. It is particularly important to be called after S3 writes, as otherwise the writes will not take effect.

func (*VFS) CreateBucket Uses

func (v *VFS) CreateBucket(uri string) error

CreateBucket creates an object-store bucket with the input URI.

func (*VFS) CreateDir Uses

func (v *VFS) CreateDir(uri string) error

CreateDir creates a directory with the input URI.

func (*VFS) EmptyBucket Uses

func (v *VFS) EmptyBucket(uri string) error

EmptyBucket empty a bucket

func (*VFS) FileSize Uses

func (v *VFS) FileSize(uri string) (uint64, error)

FileSize retrieves the size of a file.

func (*VFS) Free Uses

func (v *VFS) Free()

Free tiledb_vfs_t c structure that was allocated on the heap

func (*VFS) IsBucket Uses

func (v *VFS) IsBucket(uri string) (bool, error)

IsBucket checks if an object-store bucket with the input URI exists.

func (*VFS) IsDir Uses

func (v *VFS) IsDir(uri string) (bool, error)

IsDir checks if a directory with the input URI exists.

func (*VFS) IsEmptyBucket Uses

func (v *VFS) IsEmptyBucket(uri string) (bool, error)

IsEmptyBucket check if a bucket is empty

func (*VFS) IsFile Uses

func (v *VFS) IsFile(uri string) (bool, error)

IsFile checks if a file with the input URI exists.

func (*VFS) MoveDir Uses

func (v *VFS) MoveDir(oldURI string, newURI string) error

MoveDir menames a TileDB directory from an old URI to a new URI.

func (*VFS) MoveFile Uses

func (v *VFS) MoveFile(oldURI string, newURI string) error

MoveFile renames a TileDB file from an old URI to a new URI.

func (*VFS) Open Uses

func (v *VFS) Open(uri string, mode VFSMode) (*VFSfh, error)

Open prepares a file for reading/writing.

func (*VFS) Read Uses

func (v *VFS) Read(fh *VFSfh, offset uint64, nbytes uint64) ([]byte, error)

Read part of a file

func (*VFS) RemoveBucket Uses

func (v *VFS) RemoveBucket(uri string) error

RemoveBucket deletes an object-store bucket with the input URI.

func (*VFS) RemoveDir Uses

func (v *VFS) RemoveDir(uri string) error

RemoveDir removes a directory (recursively) with the input URI.

func (*VFS) RemoveFile Uses

func (v *VFS) RemoveFile(uri string) error

RemoveFile deletes a file with the input URI.

func (*VFS) Sync Uses

func (v *VFS) Sync(fh *VFSfh) error

Sync (flushes) a file.

func (*VFS) Touch Uses

func (v *VFS) Touch(uri string) error

Touch a file, i.e., creates a new empty file.

func (*VFS) Write Uses

func (v *VFS) Write(fh *VFSfh, bytes []byte) error

Write the contents of a buffer into a file. Note that this function only appends data at the end of the file. If the file does not exist, it will be created

type VFSMode Uses

type VFSMode int8

VFSMode is virtual file system file open mode

const (
    // TILEDB_VFS_READ open file in read mode
    TILEDB_VFS_READ VFSMode = C.TILEDB_VFS_READ

    // TILEDB_VFS_WRITE open file in write mode
    TILEDB_VFS_WRITE VFSMode = C.TILEDB_VFS_WRITE

    // TILEDB_VFS_APPENDopen file in write append mode
    TILEDB_VFS_APPEND VFSMode = C.TILEDB_VFS_APPEND
)

type VFSfh Uses

type VFSfh struct {
    // contains filtered or unexported fields
}

VFSfh is a virtual file system file handler

func (*VFSfh) Free Uses

func (v *VFSfh) Free()

Free a tiledb c vfs file handler

func (*VFSfh) IsClosed Uses

func (v *VFSfh) IsClosed() (bool, error)

IsClosed checks a vfs file handler to see if it is closed. Return true if file handler is closed, false if its not closed and error is non-nil on error

Package tiledb imports 8 packages (graph). Updated 2018-10-23. Refresh now. Tools for package owners.