Change Password

Please enter the password.
Please enter the password. Between 8-64 characters. Not identical to your email address. Contain at least 3 of uppercase, lowercase, numbers, and special characters (such as @*&#).
Please enter the password.
Submit

Change Nickname

Current Nickname:
Submit

v4.2
Search
中文EN
v4.2

    Alias Structs

    DataItem

    Using methods get() and alias() of Response will return struct DataItem.

    DataItem has below methods:

    Method Type Description
    AsNodes() []*structs.Node, map[string]*structs.Schema, error convert *DataItem of NODE type to []*structs.Node, map[string]*structs.Schema, etc.
    AsFirstNode() *structs.Node, error acquire the first *structs.Node from *DataItem of NODE type
    AsEdges() []*structs.Edge, map[string]*structs.Schema, error convert *DataItem of EDGE type to []*structs.Edge, map[string]*structs.Schema, etc.
    AsFirstEdge() *structs.Edge, error acquire the first *structs.Edge from *DataItem of EDGE type
    AsPaths() []*structs.Path, error convert *DataItem of PATH type to []*structs.Path
    AsGraphs() []*structs.Graph, error convert *DataItem with alias _graph to []*structs.Graph
    AsSchemas() []*structs.Schema, error convert *DataItem with alias _nodeSchema, _edgeSchema to []*structs.Schema
    AsProperties() []*structs.Property, error convert *DataItem with alias _nodeProperty, _edgeProperty to []*structs.Property
    AsAlgos() []*structs.Algo, error convert *DataItem with alias _algoList to []*structs.Algo
    AsTable() *structs.Table, error convert *DataItem of TABLE type to *structs.Table
    AsArray() *structs.Array, error convert *DataItem of ARRAY type to *structs.Array
    AsAttr() *structs.Attr, error convert *DataItem of ATTR type to *structs.Attr

    It is also legal to convert *DataItem with alias _graph, _nodeSchema, _edgeSchema, etc., to *structs.Table using method asTable().

    Node

    structs.Node has below fields:

    Field Type Description
    ID types.ID Node ID
    UUID types.UUID Node UUID
    Schema string Node Schema
    Values *Value Node customer properties
    Name string Node alias

    structs.Node has below methods:

    Method Type Description
    GetID() types.ID acquire ID of current Node
    GetUUID() types.UUID acquire UUID of current Node
    GetSchema() string acquire Schema of current Node
    GetValues() *Value acquire Values (custom properties) of current Node
    Get(key string) interface{} acquire a custom property of current Node
    GetBytes(key string) []byte, error acquire the []byte of a custom property of current Node
    Set(key string, value interface{}) error set a custom property of current Node, or add KV pair if 'key' is not an existing key

    Example: Send UQL query for a node list, print the ID of 2nd node, and set 'rating' of the 1st node to 8

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("find().nodes({@movie}) as nodes return nodes{*} limit 5", nil)
    	nodes, schemas, _ := resp.Alias("nodes").AsNodes()
    	firstNode, _ := resp.Alias("nodes").AsFirstNode()
    
    	printers.PrintNodes(nodes, schemas)
    	fmt.Println("ID of 2nd node is: ", nodes[1].GetID())
      	fmt.Println("rating of 1st node was: ", firstNode.Get("rating"))
    	firstNode.Set("rating", int32(8))
    	fmt.Println("rating of 1st node now is: ", firstNode.Get("rating"))
    }
    

    Output:

    +------------------------+------+--------+--------+------+
    |           ID           | UUID | Schema | rating | year |
    +------------------------+------+--------+--------+------+
    | ULTIPA80000000000003E9 | 1001 | movie  |   9    | 1994 |
    | ULTIPA80000000000003EA | 1002 | movie  |   7    | 1993 |
    | ULTIPA80000000000003EB | 1003 | movie  |   6    | 1998 |
    | ULTIPA80000000000003EC | 1004 | movie  |   9    | 1994 |
    | ULTIPA80000000000003ED | 1005 | movie  |   9    | 1997 |
    +------------------------+------+--------+--------+------+
    ID of 2nd node is:  ULTIPA80000000000003EA
    rating of 1st node was: 9
    rating of 1st node now is:  8
    

    Edge

    structs.Edge has below fields:

    Field Type Description
    From types.ID Edge start node ID
    To types.ID Edge end node ID
    FromUUID types.UUID Edge start node UUID
    ToUUID types.UUID Edge end node UUID
    UUID types.UUID Edge UUID
    Schema string Edge Schema
    Values *Value Edge customer properties
    Name string Edge alias

    structs.Edge has below methods:

    Method Type Description
    GetFrom() types.ID acquire ID of start node of current Edge
    GetTo() types.ID acquire ID of end node of current Edge
    GetUUID() types.UUID acquire UUID of current Edge
    GetSchema() string acquire Schema of current Edge
    GetValues() *Value acquire Values (custom properties) of current Edge
    Get(key string) interface{} acquire a custom property of current Edge
    GetBytes(key string) []byte, error acquire the []byte of a custom property of current Edge
    Set(key string, value interface{}) error set a custom property of current Edge, or add KV pair if 'key' is not an existing key

    Example: Send UQL query for an edge list, print the ID of the start node of the 2nd edge, and add 'value' for the 1st edge and set to 8

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("find().edges({@default}) as edges return edges{*} limit 5", nil)
    	edges, schemas, _ := resp.Alias("edges").AsEdges()
    	firstEdge, _ := resp.Alias("edges").AsFirstEdge()
    
    	printers.PrintEdges(edges, schemas)
    	fmt.Println("ID of start node of 2nd edge is: ", edges[1].GetFrom())
    	fmt.Println("value of 1st edge was: ", firstEdge.Get("value"))
    	firstEdge.Set("value", int32(8))
    	fmt.Println("value of 1st edge now is: ", firstEdge.Get("value"))
    }
    

    Output:

    +------+------------------------+------------------------+---------+
    | UUID |          FROM          |           TO           | SCHEMA  |
    +------+------------------------+------------------------+---------+
    |  21  |     ULTIPA0000003      |     ULTIPA0000004      | default |
    |  24  | ULTIPA8000000000000001 | ULTIPA8000000000000002 | default |
    |  29  | ULTIPA800000000000001A | ULTIPA800000000000001B | default |
    +------+------------------------+------------------------+---------+
    ID of start node of 2nd edge is:  ULTIPA8000000000000001
    value of 1st edge was:  <nil>
    value of 1st edge now is:  8
    

    Path

    structs.Path has below fields:

    Field Type Description
    Nodes []*Node []*Node of Path
    Edges []*Edge []*Edge of Path
    NodeSchemas map[string]*Schema Map of all node *Schema of Path
    EdgeSchemas map[string]*Schema Map of all edge *Schema of Path
    Name string Path alias

    structs.Path has below methods:

    Method Type Description
    GetLength() int acquire length of current Path, namely the number of Edge
    GetNodes() []*Node acquire []*Node of current Path
    GetEdges() []*Edge acquire []*Edge of current Path
    GetLastNode() *Node acquire the last *Node of current Path

    Example: Send UQL query for a path list, print the node list of the 1st path

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("n().e()[2].n() as paths return paths{*} limit 3", nil)
    	paths, _ := resp.Alias("paths").AsPaths()
    
    	printers.PrintPaths(paths)
    	printers.PrintNodes(paths[0].GetNodes(), paths[0].NodeSchemas)
    }
    

    Output:

    +---+---------------------------------------------------------+
    | # | Path                                                    |
    +---+---------------------------------------------------------+
    | 0 | (CARD00001) <- [14] - (CARD00020) <- [25] - (CARD00019) |
    | 1 | (CARD00001) <- [39] - (CARD00024) <- [22] - (CARD00045) |
    | 2 | (CARD00001) <- [53] - (CARD00022) <- [13] - (CARD00042) |
    +---+---------------------------------------------------------+
    +-----------+------+---------+----------+-------+
    |    ID     | UUID | Schema  | balance  | level |
    +-----------+------+---------+----------+-------+
    | CARD00001 |   1  | default |  4245.3  |   3   |
    | CARD00020 |  20  | default |  2564.0  |   2   |
    | CARD00019 |  19  | default |   244.8  |   2   |
    +-----------+------+---------+----------+-------+
    

    Graph

    structs.Graph has below fields:

    Field Type Description
    ID types.ID Graph ID
    Name string Graph name
    Description string Graph description
    TotalNodes uint64 Graph total number of nodes
    TotalEdges uint64 Graph total number of edges
    Status string Graph status (MOUNTED or UNMOUNTED)

    Example: Send UQL query for a graph list, print the graph table

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("show().graph()", nil)
    	graphs, _ := resp.Alias("_graph").AsGraphs()
    
    	printers.PrintGraph(graphs)
    }
    

    Output:

    +----------------+-------------+------------+------------+-----------+
    | Name           | Description | Total Node | Total Edge | Status    |
    +----------------+-------------+------------+------------+-----------+
    | DeliveryCenter |             | 30         | 77         | MOUNTED   |
    | GithubSocial   |             | 37700      | 289003     | MOUNTED   |
    | HB_POC         |             | 0          | 0          | UNMOUNTED |
    | Industry       |             | 0          | 0          | MOUNTED   |
    +----------------+-------------+------------+------------+-----------+
    

    Schema

    structs.Schema has below fields:

    Field Type Description
    Name string Schema name
    Properties []*Property []*Property of Schema
    Desc string Schema description
    Type string Schema type (Node or Edge)
    DBType ultipa.DBType Schema type (Node or Edge)
    Total int Schema total number of nodes/edges

    structs.Schema has below methods:

    Method Type Description
    GetProperty(name string) *Property acquire a *Property of current Schema by name

    Example: Send UQL query for the node schema list, print the schema table

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("show().node_schema()", nil)
    	nodeSchemas, _ := resp.Alias("_nodeSchema").AsSchemas()
    
    	printers.PrintSchema(nodeSchemas)
    }
    

    Output:

    Schema Name:  default ( 3 )
    Description:  default schema
    -
    Schema Name:  movie ( 92 )
    Description:  
    +-----------+-------------+-----------+-------+--------+
    | Name      | Description | Type      | LTE   | Schema |
    +-----------+-------------+-----------+-------+--------+
    | note      |             | string    | false | movie  |
    | frating   |             | float     | false | movie  |
    | timestamp |             | timestamp | false | movie  |
    | drating   |             | double    | false | movie  |
    | genre     |             | string    | false | movie  |
    | datetime  |             | datetime  | false | movie  |
    | name      |             | string    | false | movie  |
    | rating    |             | int32     | false | movie  |
    | year      |             | int32     | true  | movie  |
    +-----------+-------------+-----------+-------+--------+
    -
    Schema Name:  country ( 23 )
    Description:  
    +------+-------------+--------+-------+---------+
    | Name | Description | Type   | LTE   | Schema  |
    +------+-------------+--------+-------+---------+
    | name |             | string | false | country |
    +------+-------------+--------+-------+---------+
    -
    

    Property

    structs.Property has below fields:

    Field Type Description
    Name string Property name
    Desc string Property description
    Schema string Property Schema
    Type ultipa.PropertyType Property data type
    Lte bool Property LTE status (true or false)

    Example: Send UQL query for the node property list, print the property table

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("show().node_property()", nil)
    	nodeProperties, _ := resp.Alias("_nodeProperty").AsProperties()
    
    	printers.PrintProperty(nodeProperties)
    }
    

    Output:

    +-----------+-------------+-----------+-------+-----------+
    | Name      | Description | Type      | LTE   | Schema    |
    +-----------+-------------+-----------+-------+-----------+
    | note      |             | string    | false | movie     |
    | frating   |             | float     | false | movie     |
    | timestamp |             | timestamp | false | movie     |
    | drating   |             | double    | false | movie     |
    | genre     |             | string    | false | movie     |
    | datetime  |             | datetime  | false | movie     |
    | name      |             | string    | false | movie     |
    | rating    |             | int32     | false | movie     |
    | year      |             | int32     | true  | movie     |
    | name      |             | string    | false | country   |
    | name      |             | string    | false | celebrity |
    | name      |             | string    | false | account   |
    | industry  |             | string    | false | account   |
    | gender    |             | string    | false | account   |
    | year      |             | int32     | true  | account   |
    +-----------+-------------+-----------+-------+-----------+
    

    Algo

    structs.Algo has below fields:

    Field Type Description
    Name string Algo name
    Desc string Algo description
    Version string Algo version
    Params map[string]*AlgoParam Algo parameters

    structs.Algo has below methods:

    Method Type Description
    ParamsToString() string convert Params of current Algo to string

    Example: Send UQL query for the installed algorithm list, print the algorithm table

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("show().algo()", nil)
    	algos, _ := resp.Alias("_algoList").AsAlgos()
    
    	printers.PrintAlgoList(algos)
    }
    

    Output:

    +-------------------+-------------------------------------+---------+----------------------------------------------------------+
    | Algo Name         | Description                         | Version | Parameters                                               |
    +-------------------+-------------------------------------+---------+----------------------------------------------------------+
    | triangle_counting | triangle counting                   | 1.0.2   | type : 1:count by edge  2:count by node                  |
    |                   |                                     |         | limit : -1 for all triples                               |
    |                   |                                     |         | result_type : 1:only number 2:triangles                  |
    |                   |                                     |         |                                                          |
    | sybil_rank        | sybil rank                          | 1.0.1   | trust_seeds : array of nodes,required                    |
    |                   |                                     |         | loop_num : size_t,required                               |
    |                   |                                     |         | limit : optional,-1 for all results, >=0 partial results |
    |                   |                                     |         | total_trust : float,required                             |
    |                   |                                     |         |                                                          |
    | subgraph          | subgraph generated by certain nodes | 1.0.2   | ids : array of nodes,required                            |
    |                   |                                     |         | limit : optional,-1 for all results, >=0 partial results |
    |                   |                                     |         |                                                          |
    +-------------------+-------------------------------------+---------+----------------------------------------------------------+
    

    Table

    structs.Table has below fields:

    Field Type Description
    Name string Table alias
    Headers []*Property Table headers
    Rows []*Row Table rows

    structs.Table has below methods:

    Method Type Description
    GetHeaders() []*Property acquire current Table headers
    GetRows() []*Row acquire current Table rows
    ToKV() []*Values convert current Table to KV list

    Example: Send UQL query for a table, print the headers and the 2nd row:

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("find().nodes({@account}) limit 5 return table(nodes.gender, nodes.year) as myTable", nil)
    	table, _ := resp.Alias("myTable").AsTable()
    
    	printers.PrintTable(table)
    	printers.PrintProperty(table.GetHeaders())
    	fmt.Println(*table.GetRows()[0])
    }
    

    Output:

    +--------------+------------+
    | nodes.gender | nodes.year |
    +--------------+------------+
    |    female    |    1978    |
    |    female    |    1989    |
    |     male     |    1982    |
    |    female    |    2007    |
    |     male     |    1973    |
    +--------------+------------+
    +--------------+-------------+--------+-------+--------+
    | Name         | Description | Type   | LTE   | Schema |
    +--------------+-------------+--------+-------+--------+
    | nodes.gender |             | string | false |        |
    | nodes.year   |             | int32  | false |        |
    +--------------+-------------+--------+-------+--------+
    [female 1978]
    

    Array

    structs.Array has below fields:

    Field Type Description
    Name string Array alias
    Rows []*Row Array rows

    Example: Send UQL query for an array list, print the 3rd element of the 2nd array

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("find().nodes({@account}) as nodes group by nodes.industry return collect(nodes.name) as myArray limit 3", nil)
    	array, _ := resp.Alias("myArray").AsArray()
    
    	printers.PrintArray(array)
    	fmt.Println("3rd element of 2nd array is: ", (*array.Rows[1])[2])
    }
    

    Output:

    +-------------------------------------------------------------+
    | myArray                                                     |
    +-------------------------------------------------------------+
    | ["jibber-jabber", "jo", "CR.", "laofung", "pepe"]           |
    | ["Meng", "HolyC", "pixiedust", "sadmov"]                    |
    | ["Unbeliever", "Ivo", "Nannobrycon", "auric", "Blair_self"] |
    +-------------------------------------------------------------+
    3rd element of 2nd array is:  pixiedust
    

    Attr

    structs.Attr has below fields:

    Field Type Description
    Name string Attr alias
    Rows Row Attr rows
    PropertyType ultipa.PropertyType Attr type

    Example: Send UQL query for an attribute list, print the 2nd attribute

    func TestMisc(t *testing.T) {
        // omit code of establishing server connection 'conn'
    
    	resp, _ := conn.UQL("find().nodes({@account}) as nodes return nodes.industry as myAttr limit 5", nil)
    	attribute, _ := resp.Alias("myAttr").AsAttr()
    
    	printers.PrintAttr(attribute)
    	fmt.Println("2nd attr is: ", attribute.Rows[1])
    }
    

    Output:

    +---------------+
    | myAttr        |
    +---------------+
    | Manufacturing |
    | Health        |
    | Other         |
    | Education     |
    | Publishing    |
    +---------------+
    2nd attr is:  Health
    
    Please complete the following information to download this book
    *
    公司名称不能为空
    *
    公司邮箱必须填写
    *
    你的名字必须填写
    *
    你的电话必须填写
    *
    你的电话必须填写