@ultipa-graph/ultipa-node-sdk
Version:
NodeJS SDK for ultipa-server 4.0
455 lines (454 loc) • 10.6 kB
TypeScript
import { ResponseType } from '.';
export declare namespace ULTIPA {
/**
* Raft集群的类型
*/
enum ClientType {
Default = 0,
Algo = 1,
Update = 2,
Leader = 3
}
interface TimeZone {
timeZone?: string;
timeZoneOffset?: number;
timestampToString?: boolean;
}
/**
* 连接的配置
*/
class UltipaConfig {
useHost?: string;
graphSetName?: string;
clusterId?: string;
timeZone?: string;
timeZoneOffset?: number;
timestampToString?: boolean;
logUql?: boolean;
timeout?: number;
threadNum?: number;
responseWithRequestInfo?: boolean;
consistency?: boolean;
}
/**
* 属性类型
*/
enum PropertyType {
PROPERTY_UNSET,
PROPERTY_INT32,
PROPERTY_STRING,
PROPERTY_FLOAT,
PROPERTY_DOUBLE,
PROPERTY_UINT32,
PROPERTY_INT64,
PROPERTY_UINT64,
PROPERTY_DATETIME,
PROPERTY_TIMESTAMP,
PROPERTY_TEXT,
PROPERTY_BLOB,
PROPERTY_POINT,
PROPERTY_DECIMAL,
PROPERTY_LIST,
PROPERTY_SET,
PROPERTY_MAP,
PROPERTY_NULL,
unset,
int32,
string,
float,
double,
uint32,
int64,
uint64,
datetime,
timestamp,
text,
blob,
point,
decimal,
list,
set,
map,
null
}
/**
* 返回状态码
*/
enum Code {
SUCCESS,
FAILED,
PARAM_ERROR,
BASE_DB_ERROR,
ENGINE_ERROR,
SYSTEM_ERROR,
RAFT_REDIRECT,
RAFT_LEADER_NOT_YET_ELECTED,
RAFT_LOG_ERROR,
UQL_ERROR,
NOT_RAFT_MODE,
RAFT_NO_AVAILABLE_FOLLOWERS,
RAFT_NO_AVAILABLE_ALGO_SERVERS,
PERMISSION_DENIED,
UNKNOWN_ERROR = 1000
}
enum ResultType {
RESULT_TYPE_UNSET,
RESULT_TYPE_PATH,
RESULT_TYPE_NODE,
RESULT_TYPE_EDGE,
RESULT_TYPE_ATTR,
RESULT_TYPE_TABLE,
RESULT_TYPE_GRAPH
}
enum AuthenticateType {
PERMISSION_TYPE_UQL,
PERMISSION_TYPE_INSERTNODES,
PERMISSION_TYPE_INSERTEDGES,
PERMISSION_TYPE_EXPORT,
PERMISSION_TYPE_DOWNLOADFILE,
PERMISSION_TYPE_INSTALLALGO,
PERMISSION_TYPE_UNINSTALLALGO,
PERMISSION_TYPE_UPLOADER,
PERMISSION_TYPE_CREATEGRAPHBYUPLOADER,
PERMISSION_TYPE_INSTALLEXTA,
PERMISSION_TYPE_UNINSTALLEXTA
}
enum InsertType {
INSERT_TYPE_NORMAL,
INSERT_TYPE_OVERWRITE,
INSERT_TYPE_UPSERT
}
/**
* 数据库类型
*/
enum DBType {
/**
* 点
*/
DBNODE,
/**
* 边
*/
DBEDGE
}
/**
* Raft从节点的规则
*/
enum RaftFollowerRole {
ROLE_UNSET,
ROLE_READABLE,
ROLE_ALGO_EXECUTABLE
}
/**
* 算法任务的状态
*/
enum Task_Status {
pending,
computing,
writing,
done,
failed,
stopped
}
/**
* Raft节点的信息
*/
type RaftPeerInfo = {
host: string;
status: boolean;
isLeader: boolean;
isFollowerReadable: boolean;
isAlgoExecutable: boolean;
isUnset: boolean;
};
/**
* 连接返回的统一状态
*/
type Status = {
code: number;
code_desc?: string;
message: string;
clusterInfo?: {
redirect: string;
raftPeers: RaftPeerInfo[];
};
};
type ResultAlias = {
alias: string;
result_type: ResultType;
};
type ResultAliases = ResultAlias[];
/**
* 点的结构
*/
class Node {
schema: string;
id: string;
uuid: string;
values: object;
getID(): string;
getUUID(): string;
getSchema(): string;
getValues(): object;
get(prop_name: string): any;
set(prop_name: string, value: any): void;
}
type NodeTable = Node[];
/**
* 一组点
*/
type NodeAlias = {
nodes: NodeTable;
alias: string;
};
/**
* 边的结构
*/
class Edge {
schema: string;
from: string;
to: string;
uuid: string;
from_uuid: string;
to_uuid: string;
values: object;
getUUID(): string;
getSchema(): string;
getFrom(): string;
getFromUUID(): string;
getTo(): string;
getToUUID(): string;
getValues(): object;
get(prop_name: string): any;
set(prop_name: string, value: any): void;
}
type EdgeTable = Edge[];
/**
* 一组边
*/
type EdgeAlias = {
edges: EdgeTable;
alias: string;
};
type GraphAlias = {
graph: Graph;
alias: string;
};
class Graph {
nodes: NodeTable;
edges: EdgeTable;
getNodes(): NodeTable;
getEdges(): EdgeTable;
}
/**
* 路径的结构
*/
class Path extends Graph {
length: number;
getLength(): number;
}
type Paths = Path[];
type PathAlias = {
alias: string;
paths: Paths;
};
type Header = {
name: string;
type: PropertyType;
subTypes?: PropertyType[];
};
type Property = Header;
type Schema = {
dbType: DBType;
name: string;
desc?: string;
properties?: Property[];
};
type Statistics = {
totalCost: number;
engineCost: number;
nodeAffected?: number;
edgeAffected?: number;
};
/**
* 表格的结构
*/
class Table {
name: string;
alias: string;
headers: string[];
rows: any[][];
toKV(): any[];
getHeaders(): string[];
getRows(): any[][];
}
type AttrAlias = {
values: any[];
type: ResultType;
type_desc: string;
alias: string;
};
type AttrNodesAlias = {
values: Node[][];
type: ResultType;
type_desc: string;
alias: string;
};
type AttrEdgesAlias = {
values: Edge[][];
type: ResultType;
type_desc: string;
alias: string;
};
type AttrPathsAlias = {
values: Path[][];
type: ResultType;
type_desc: string;
alias: string;
};
/**
* 一组属性
*/
type AttrNewAlias = {
attr: Attr;
alias: string;
};
type Attr = {
type: PropertyType;
type_desc: string;
values: any[];
has_attr_data: boolean;
has_ultipa_data: boolean;
};
type AttrListData = {
type: ResultType;
type_desc: string;
nodes?: NodeTable;
edges?: EdgeTable;
paths?: Paths;
attrs?: Attr[];
};
type AttrMapData = {
key: Attr;
value: Attr;
};
type ListData = {
values: any[];
};
type SetData = ListData;
type MapValue = {
key: any;
value: any;
};
type MapData = {
values: MapData[];
};
type ExplainPlan = {
plan_nodes: PlanNode[];
};
type PlanNode = {
alias: string;
children_num: number;
children?: PlanNode[] | null;
uql: string;
infos: string;
};
/**
* uql统一返回结构体的data
*/
type UQLReplyBase = {
total_time_cost: number;
engine_time_cost: number;
results?: ResultAlias[];
paths?: PathAlias[];
nodes?: NodeAlias[];
edges?: EdgeAlias[];
attrs?: AttrAlias[];
tables?: Table[];
graphs?: GraphAlias[];
statistics: Statistics;
explainPlans?: ExplainPlan;
explainPlansTreeTopNode?: PlanNode;
};
function getExplainPlansTreeTopNode(plans: ExplainPlan): PlanNode;
class UQLReply {
aliasMap: {
[x: string]: DataItem;
};
datas: DataItem[];
statistics: Statistics;
explainPlansTreeTopNode: PlanNode;
constructor(uqlReplyBase: UQLReplyBase);
private defaultValueFromType;
___aliasMapFromDatas(): void;
isEmpty(): boolean;
singleDataNodes(): Node[];
singleDataEdges(): Edge[];
singleDataPaths(): any;
getTables(): Table[];
singleDataTables(): Table;
singleDataGraph(): Graph;
singleDataAttrs(): AttrAlias;
get(index: number): DataItem;
alias(alias: string): DataItem;
toJSON(): {
statistics: Statistics;
explainPlansTreeTopNode: PlanNode;
datas: DataItem[];
};
}
class DataItem {
data: any;
type: ResultType;
type_desc: string;
alias: string;
constructor(alias: string, data: any, type: ResultType);
private _asTypeError;
asEdges(): EdgeTable;
asPaths(): Paths;
asNodes(): NodeTable;
asTable(): Table;
asGraph(): Graph;
asAttrs(): AttrAlias;
asNodeList(): AttrNodesAlias;
asEdgeList(): AttrEdgesAlias;
asPathList(): AttrPathsAlias;
asGraphInfos(): ResponseType.GraphSet[];
asProperties(): ResponseType.Property[];
asSchemas(): ResponseType.Schema[];
asAlgos(): ResponseType.Algo[];
asExtas(): ResponseType.Exta[];
asTasks(): ResponseType.Task[];
asAny(): any;
asTableWithT<T>(): T[];
toJSONString(): string;
}
/**
* 所有请求的统一返回结构体
*/
class Response<T> {
req?: any;
status: Status;
data?: T;
statistics?: Statistics;
explainPlans?: ExplainPlan;
}
/**
* uql请求的返回结构体
*/
class UQLResponse extends Response<ULTIPA.UQLReply> {
}
function NewUQLResponse(jsonObj: any): UQLResponse;
class UQLBaseResponse extends Response<ULTIPA.UQLReplyBase> {
}
function NewUQLBaseResponse(jsonObj: any): UQLBaseResponse;
function formatBaseResponse(base: UQLBaseResponse): any;
class UQLSingleResponse {
responseWithoutData: Response<null>;
uqlReply: UQLReply;
}
class TruncateType {
node: string;
edge: string;
}
}