goskizze: github.com/skizzehq/goskizze/skizze Index | Files

package skizze

import "github.com/skizzehq/goskizze/skizze"

Package skizze is a client for the Skizze database.

The Skizze repository (https://github.com/skizzehq/skizze) provides more information about Skizze and how to use it.

Example:

 package main

 import (
   "fmt"

   "github.com/skizzehq/goskizze/skizze"
 )

 func main() {
   client, err := skizze.Dial("127.0.0.1:3596", skizze.Options{Insecure: true})
   if err != nil {
     fmt.Printf("Error connecting to Skizze: %s\n", err)
     return
   }

   // A domain is an easy way to use the same data set for multiple statistics
   name := "testdomain"
   client.CreateDomain(name)

  // Adding values to a domain will trigger statistics generation for each of
  // the supported Sketches in the domain
  client.AddToDomain(name, "alvin", "simon", "theodore")

  // The Membership sketch will test if a value resides in a data set, returning
  // true or false
  membs, _ := client.GetMembership(name, "alvin", "simon", "theodore", "gary")
  for _, m := range membs {
    fmt.Printf("MEMB: %s is in %s: %v\n", m.Value, name, m.IsMember)
  }

  // The Frequency sketch will return how many times a value occurs in a sketch
  freqs, _ := client.GetFrequency(name, "alvin", "simon", "theodore", "gary")
  for _, f := range freqs {
    fmt.Printf("FREQ: %s appears in %s %v times\n", f.Value, name, f.Count)
  }

  // The Rankings sketch will always keep the top N (configurable) rankings and
  // their occurrance counts
  ranks, _ := client.GetRankings(name)
  for i, r := range ranks {
    fmt.Printf("RANK: #%v = %s (count=%v)\n", i, r.Value, r.Count)
  }

  // Finally, the Cardinality sketch will keep a count of how many unique items
  // have been added to the data set
  card, _ := client.GetCardinality(name)
  fmt.Printf("CARD: There are %v items in the %s domain\n\n", card, name)

  client.DeleteDomain(name)
}

Output:

MEMB: alvin is in testdomain: true
MEMB: simon is in testdomain: true
MEMB: theodore is in testdomain: true
MEMB: gary is in testdomain: false

FREQ: alvin appears in testdomain 1 times
FREQ: simon appears in testdomain 1 times
FREQ: theodore appears in testdomain 1 times
FREQ: gary appears in testdomain 0 times

RANK: #0 = alvin (count=1)
RANK: #1 = simon (count=1)
RANK: #2 = theodore (count=1)

CARD: There are 3 items in the testdomain domain

For a full guide, visit https://github.com/skizzehq/goskizze.

Index

Package Files

client.go doc.go domain.go options.go properties.go result.go sketch.go snapshot.go

type Client Uses

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

Client represents a a thread-safe connection to Skizze

func Dial Uses

func Dial(address string, opts Options) (*Client, error)

Dial initalizes a connection to Skizze and returns a client

func (*Client) AddToDomain Uses

func (c *Client) AddToDomain(name string, values ...string) error

AddToDomain will add the supplied values to the domain's data set.

func (*Client) AddToSketch Uses

func (c *Client) AddToSketch(name string, t SketchType, values ...string) error

AddToSketch will add the supplied values to the sketch's data set.

func (*Client) Close Uses

func (c *Client) Close()

Close shuts down the client connection to Skizze.

func (*Client) CreateDomain Uses

func (c *Client) CreateDomain(name string) (*Domain, error)

CreateDomain creates a new domain with default properties per Sketch.

func (*Client) CreateDomainWithProperties Uses

func (c *Client) CreateDomainWithProperties(name string, props *DomainProperties) (*Domain, error)

CreateDomainWithProperties creates a domain with customized properties.

func (*Client) CreateSketch Uses

func (c *Client) CreateSketch(name string, t SketchType, p *Properties) (*Sketch, error)

CreateSketch creates a new sketch.

func (*Client) DeleteDomain Uses

func (c *Client) DeleteDomain(name string) error

DeleteDomain deletes a domain

func (*Client) DeleteSketch Uses

func (c *Client) DeleteSketch(name string, t SketchType) error

DeleteSketch deletes a sketch

func (*Client) GetCardinality Uses

func (c *Client) GetCardinality(name string) (int64, error)

GetCardinality queries the sketch for the cardinality of items.

func (*Client) GetDomain Uses

func (c *Client) GetDomain(name string) (*Domain, error)

GetDomain gets the details of a domain.

func (*Client) GetFrequency Uses

func (c *Client) GetFrequency(name string, values ...string) (ret []*FrequencyResult, err error)

GetFrequency queries the sketch for frequency for the provided values.

func (*Client) GetMembership Uses

func (c *Client) GetMembership(name string, values ...string) (ret []*MembershipResult, err error)

GetMembership queries the sketch for membership (true/false) for the provided values.

func (*Client) GetMultiCardinality Uses

func (c *Client) GetMultiCardinality(names []string) (ret []int64, err error)

GetMultiCardinality queries multiple sketches for the cardinality of items.

func (*Client) GetMultiFrequency Uses

func (c *Client) GetMultiFrequency(names []string, values ...string) (ret [][]*FrequencyResult, err error)

GetMultiFrequency queries multiple sketches for the frequency of the provided values.

func (*Client) GetMultiMembership Uses

func (c *Client) GetMultiMembership(names []string, values ...string) (ret [][]*MembershipResult, err error)

GetMultiMembership queries multiple sketches for membership of the provided values.

func (*Client) GetMultiRankings Uses

func (c *Client) GetMultiRankings(names []string) (ret [][]*RankingsResult, err error)

GetMultiRankings queries multiple sketches for the top rankings.

func (*Client) GetRankings Uses

func (c *Client) GetRankings(name string) (ret []*RankingsResult, err error)

GetRankings queries the sketch for the top rankings.

func (*Client) GetSketch Uses

func (c *Client) GetSketch(name string, t SketchType) (*Sketch, error)

GetSketch gets the details of a sketch.

func (*Client) ListAll Uses

func (c *Client) ListAll() (ret []*Sketch, err error)

ListAll gets all the available Sketches.

func (*Client) ListDomains Uses

func (c *Client) ListDomains() (ret []string, err error)

ListDomains gets all the available domains

func (*Client) ListSketches Uses

func (c *Client) ListSketches(t SketchType) (ret []*Sketch, err error)

ListSketches gets all the sketches of the specified type.

type Domain Uses

type Domain struct {
    Name     string
    Sketches []*Sketch
}

Domain describes details of a Skizze domain

type DomainProperties Uses

type DomainProperties struct {
    MembershipProperties Properties
    FrequencyProperties  Properties
    RankingsProperties   Properties
}

DomainProperties details configuration for Sketches in a domain

type FrequencyResult Uses

type FrequencyResult struct {
    Value string
    Count int64
}

FrequencyResult indicates the result of a frequency query for a value.

type MembershipResult Uses

type MembershipResult struct {
    Value    string
    IsMember bool
}

MembershipResult indicates the result of a membership query for a value.

type Options Uses

type Options struct {
    // Insecure disables transport security for the Client connection.
    Insecure bool
}

Options contains connection options

type Properties Uses

type Properties struct {
    MaxUniqueItems int64
    ErrorRate      float32

    // Size is used by Rankings sketches to determine the number of rankings this
    // Sketch should track e.g. top 10, top 100, top 1000
    Size int64
}

Properties are configuration settings for a Sketch.

type RankingsResult Uses

type RankingsResult struct {
    Value string
    Count int64
}

RankingsResult indicates the result of a ranking query for a value.

type Sketch Uses

type Sketch struct {
    Name       string
    Type       SketchType
    Properties *Properties
}

Sketch describes the details of a sketch

type SketchType Uses

type SketchType int

SketchType is the kind of sketch

const (
    // Membership sketches can evaluate if a data set contains an element.
    Membership SketchType = iota
    // Frequency sketches can evaluate the frequency of an element in a data set.
    Frequency
    // Ranking sketches return the top ranked elements of the data set.
    Ranking
    // Cardinality sketches evaluate how many distinct elements are in the data set.
    Cardinality
)

type Snapshot Uses

type Snapshot struct {
    Status  SnapshotState
    Message string
}

Snapshot represents details of the a snapshot

type SnapshotState Uses

type SnapshotState int

SnapshotState indicates the state of the current or previous snapshot.

const (
    // Pending indicates a snapshot is waiting to be taken.
    Pending SnapshotState = iota
    // InProgress indicates a snapshot is currently being taken.
    InProgress
    // Successful indicates the last snapshot was successful.
    Successful
    // Failed indicates the last snapshot had an error.
    Failed
)

Package skizze imports 5 packages (graph) and is imported by 2 packages. Updated 2016-07-15. Refresh now. Tools for package owners.