跳转至

应用数据库☍

版本：v1

认证方式：Bearer Token

目录☍

接口列表☍

获取数据表☍

接口说明

获取当前应用的所有数据表名称

基本信息☍

  • 接口名称：获取数据表
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/Tables

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/Tables"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/Tables"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/Tables", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/Tables',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/Tables";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/Tables");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/Tables")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/Tables", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/Tables")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/Tables")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": []          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

添加数据☍

接口说明

向指定表中添加数据，可以是单个json对象或json数组

基本信息☍

  • 接口名称：添加数据
  • 请求方式：POST
  • 请求路径：/Storage/{appKey}/{table}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称（小写字母加数字,1-50位） 是
appKey - - 是
Body 参数☍

请求体引用 JToken 数据结构

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = [];
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import requests

url = "{server}/Storage/{appKey}/{table}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = []

response = requests.post(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := []
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/Storage/{appKey}/{table}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
const axios = require('axios');


const data = [];

const config = {
    method: 'post',
    url: '{server}/Storage/{appKey}/{table}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

$url = "{server}/Storage/{appKey}/{table}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = [];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = [];
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/Storage/{appKey}/{table}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = []
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
const data = [];

fetch("{server}/Storage/{appKey}/{table}", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = [];
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = []
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": ""          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data string 响应数据 否
error string 错误信息 否

查询数据☍

接口说明

根据条件查询指定表中的数据

基本信息☍

  • 接口名称：查询数据
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
filter string - 过滤，json格式 否
project string - 字段映射，json格式 否
sort string - 排序，json格式 否
startTime string - 开始时间 否
endTime string - 结束时间 否
explain boolean - 查看执行计划 否
take integer 10 默认为10 否
skip integer - 默认为0 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data StorageListResult - 否
error string 错误信息 否

数据详情☍

接口说明

获取指定表中指定ID的数据详情

基本信息☍

  • 接口名称：数据详情
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
id - 数据ID 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
project string - json格式 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/{id}", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - 响应数据 否
error string 错误信息 否

删除数据☍

接口说明

删除指定表中指定ID的数据

基本信息☍

  • 接口名称：删除数据
  • 请求方式：DELETE
  • 请求路径：/Storage/{appKey}/{table}/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
id - 数据ID 是
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/{id}"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/Storage/{appKey}/{table}/{id}", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/Storage/{appKey}/{table}/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/Storage/{appKey}/{table}/{id}");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/{id}", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

更新数据☍

接口说明

更新指定表中指定ID的数据，可以选择全量更新或部分更新

基本信息☍

  • 接口名称：更新数据
  • 请求方式：PUT
  • 请求路径：/Storage/{appKey}/{table}/{id}

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
id - 数据ID 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
replace boolean - 是否为全量更新，默认为false 否
Body 参数☍

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/{id}"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("put", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import requests

url = "{server}/Storage/{appKey}/{table}/{id}"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {}

response = requests.put(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("put", "{server}/Storage/{appKey}/{table}/{id}", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
const axios = require('axios');


const data = {};

const config = {
    method: 'put',
    url: '{server}/Storage/{appKey}/{table}/{id}',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

$url = "{server}/Storage/{appKey}/{table}/{id}";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "put");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.putAsync("{server}/Storage/{appKey}/{table}/{id}", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/{id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
const data = {};

fetch("{server}/Storage/{appKey}/{table}/{id}", {
    method: "put",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/{id}")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("put", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/{id}")!
var request = URLRequest(url: url)
request.httpMethod = "put"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

聚合查询☍

接口说明

根据聚合管道查询指定表中的数据

基本信息☍

  • 接口名称：聚合查询
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}/Aggregate

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
pipeline string - 构建聚合查询 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Aggregate"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Aggregate"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}/Aggregate", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}/Aggregate',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Aggregate";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}/Aggregate");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Aggregate")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Aggregate", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Aggregate")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Aggregate")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": []          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

导出数据☍

接口说明

根据筛选条件导出指定表中的数据

基本信息☍

  • 接口名称：导出数据
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}/Export

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
filter string - 筛选条件，json格式 否
startTime string - 开始时间 否
endTime string - 结束时间 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Export"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Export"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}/Export", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}/Export',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Export";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}/Export");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Export")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Export", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Export")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Export")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
{}

导入数据☍

接口说明

从文件导入数据到指定表中

基本信息☍

  • 接口名称：导入数据
  • 请求方式：POST
  • 请求路径：/Storage/{appKey}/{table}/Import

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
file binary - 导入的文件 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import okhttp3.*;

public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Import"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        MultipartBody.Builder builder = new MultipartBody.Builder()
            .setType(MultipartBody.FORM);

        // 添加文件
        File file = new File("{file_path}");
        RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
        builder.addFormDataPart("file", file.getName(), fileBody);

        // 添加其他字段
        builder.addFormDataPart("field1", "value1");
        builder.addFormDataPart("field2", "value2");

        RequestBody body = builder.build();

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import requests
import os

url = "{server}/Storage/{appKey}/{table}/Import"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


files = {
    'file': ('filename', open('{file_path}', 'rb'))
}
data = {
    'field1': 'value1',
    'field2': 'value2'
}

response = requests.post(
    url,
    headers=headers,
    files=files, data=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "mime/multipart"
    "os"
    "io"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    // 创建multipart writer
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // 添加文件
    file, err := os.Open("{file_path}")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    part, err := writer.CreateFormFile("file", "filename")
    if err != nil {
        panic(err)
    }
    io.Copy(part, file)

    // 添加其他字段
    writer.WriteField("field1", "value1")
    writer.WriteField("field2", "value2")

    writer.Close()

    req, err = http.NewRequest("post", "{server}/Storage/{appKey}/{table}/Import", body)
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", writer.FormDataContentType())

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
const axios = require('axios');
const FormData = require("form-data");
const fs = require("fs");


const formData = new FormData();
formData.append('file', fs.createReadStream('{file_path}'));
formData.append('field1', 'value1');
formData.append('field2', 'value2');

const config = {
    method: 'post',
    url: '{server}/Storage/{appKey}/{table}/Import',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'multipart/form-data'
    },
    data: formData
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php

$url = "{server}/Storage/{appKey}/{table}/Import";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: multipart/form-data"
];


$data = array(
    'file' => new CURLFile('{file_path}'),
    'field1' => 'value1',
    'field2' => 'value2'
);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;
using System.Net.Http.Headers;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            using (var multipartContent = new MultipartFormDataContent())
            {
                // 添加文件
                using (var fileStream = File.OpenRead("{file_path}"))
                {
                    var streamContent = new StreamContent(fileStream);
                    streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
                    multipartContent.Add(streamContent, "file", "filename");
                }

                // 添加其他字段
                multipartContent.Add(new StringContent("value1"), "field1");
                multipartContent.Add(new StringContent("value2"), "field2");

                response = await client.postAsync("{server}/Storage/{appKey}/{table}/Import", multipartContent);
            }

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
require 'net/http'
require 'json'
require "multipart-post"

uri = URI("{server}/Storage/{appKey}/{table}/Import")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "multipart/form-data"


data = {
    file: File.open("{file_path}"),
    field1: "value1",
    field2: "value2"
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
const formData = new FormData();
formData.append('file', fileInput.files[0]);
formData.append('field1', 'value1');
formData.append('field2', 'value2');

fetch("{server}/Storage/{appKey}/{table}/Import", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'multipart/form-data'
    },
    body: formData
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;
import okhttp3.MultipartBody;

public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Import")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "multipart/form-data");


        MultipartBody.Builder builder = new MultipartBody.Builder()
            .setType(MultipartBody.FORM);

        // 添加文件
        File file = new File("{file_path}");
        RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
        builder.addFormDataPart("file", file.getName(), fileBody);

        // 添加其他字段
        builder.addFormDataPart("field1", "value1");
        builder.addFormDataPart("field2", "value2");

        RequestBody body = builder.build();

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import Foundation
import UIKit

let url = URL(string: "{server}/Storage/{appKey}/{table}/Import")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("multipart/form-data; boundary=(boundary)", forHTTPHeaderField: "Content-Type")


let boundary = "Boundary-(UUID().uuidString)"
var bodyData = Data()

// 添加文件
if let fileData = try? Data(contentsOf: URL(fileURLWithPath: "{file_path}")) {
    bodyData.append("--(boundary)\r\n".data(using: .utf8)!)
    bodyData.append("Content-Disposition: form-data; name="file"; filename="filename"\r\n".data(using: .utf8)!)
    bodyData.append("Content-Type: application/octet-stream\r\n\r\n".data(using: .utf8)!)
    bodyData.append(fileData)
    bodyData.append("\r\n".data(using: .utf8)!)
}

// 添加其他字段
bodyData.append("--(boundary)\r\n".data(using: .utf8)!)
bodyData.append("Content-Disposition: form-data; name="field1"\r\n\r\n".data(using: .utf8)!)
bodyData.append("value1\r\n".data(using: .utf8)!)

bodyData.append("--(boundary)\r\n".data(using: .utf8)!)
bodyData.append("Content-Disposition: form-data; name="field2"\r\n\r\n".data(using: .utf8)!)
bodyData.append("value2\r\n".data(using: .utf8)!)

bodyData.append("--(boundary)--\r\n".data(using: .utf8)!)
request.httpBody = bodyData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

清空表数据☍

接口说明

根据筛选条件清空指定表中的数据

基本信息☍

  • 接口名称：清空表数据
  • 请求方式：DELETE
  • 请求路径：/Storage/{appKey}/{table}/Clear

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
filter string - 筛选条件，json格式 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Clear"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Clear"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/Storage/{appKey}/{table}/Clear", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/Storage/{appKey}/{table}/Clear',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Clear";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/Storage/{appKey}/{table}/Clear");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Clear")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Clear", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Clear")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Clear")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": "0"          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data integer 响应数据 否
error string 错误信息 否

删除表☍

接口说明

删除指定表

基本信息☍

  • 接口名称：删除表
  • 请求方式：DELETE
  • 请求路径：/Storage/{appKey}/{table}/Remove

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Remove"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Remove"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/Storage/{appKey}/{table}/Remove", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/Storage/{appKey}/{table}/Remove',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Remove";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/Storage/{appKey}/{table}/Remove");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Remove")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Remove", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Remove")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Remove")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

获取索引☍

接口说明

获取指定表的索引列表

基本信息☍

  • 接口名称：获取索引
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}/Indexes

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Indexes"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Indexes"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}/Indexes", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}/Indexes',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Indexes";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}/Indexes");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Indexes")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Indexes", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Indexes")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Indexes")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": []          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

删除索引☍

接口说明

删除指定表的指定索引

基本信息☍

  • 接口名称：删除索引
  • 请求方式：DELETE
  • 请求路径：/Storage/{appKey}/{table}/indexes

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
indexName string - 索引名称 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/indexes"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("delete", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/indexes"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.delete(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("delete", "{server}/Storage/{appKey}/{table}/indexes", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'delete',
    url: '{server}/Storage/{appKey}/{table}/indexes',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/indexes";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "delete");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.deleteAsync("{server}/Storage/{appKey}/{table}/indexes");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/indexes")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/indexes", {
    method: "delete",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/indexes")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("delete", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/indexes")!
var request = URLRequest(url: url)
request.httpMethod = "delete"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

添加索引☍

接口说明

为指定表添加索引

基本信息☍

  • 接口名称：添加索引
  • 请求方式：POST
  • 请求路径：/Storage/{appKey}/{table}/indexes

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称（小写字母加数字,1-50位） 是
appKey - - 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
model object - - 是
options object - - 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/indexes"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "model": {},
    "options": {}
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("post", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import requests

url = "{server}/Storage/{appKey}/{table}/indexes"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "model": {},
    "options": {}
}

response = requests.post(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "model": {},
    "options": {}
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("post", "{server}/Storage/{appKey}/{table}/indexes", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const axios = require('axios');


const data = {
    "model": {},
    "options": {}
};

const config = {
    method: 'post',
    url: '{server}/Storage/{appKey}/{table}/indexes',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php

$url = "{server}/Storage/{appKey}/{table}/indexes";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "model": {},
    "options": {}
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "post");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "model": {},
    "options": {}
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.postAsync("{server}/Storage/{appKey}/{table}/indexes", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/indexes")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "model": {},
    "options": {}
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
const data = {
    "model": {},
    "options": {}
};

fetch("{server}/Storage/{appKey}/{table}/indexes", {
    method: "post",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/indexes")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "model": {},
    "options": {}
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("post", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/indexes")!
var request = URLRequest(url: url)
request.httpMethod = "post"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "model": {},
    "options": {}
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": ""          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data string 响应数据 否
error string 错误信息 否

数据表统计☍

接口说明

获取指定表的数据统计信息

基本信息☍

  • 接口名称：数据表统计
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/{table}/Stats

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
table - 表名称 是
appKey - - 是

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/{table}/Stats"))
            .header("Authorization", "Bearer {your_access_token}");


        requestBuilder.method("get", HttpRequest.BodyPublishers.noBody());

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import requests

url = "{server}/Storage/{appKey}/{table}/Stats"
headers = {
    "Authorization": "Bearer {your_access_token}"
}

response = requests.get(
    url,
    headers=headers
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/{table}/Stats", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const axios = require('axios');

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/{table}/Stats',
    headers: {
        'Authorization': 'Bearer {your_access_token}'
    }
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<?php

$url = "{server}/Storage/{appKey}/{table}/Stats";
$headers = [
    "Authorization: Bearer {your_access_token}"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;
            response = await client.getAsync("{server}/Storage/{appKey}/{table}/Stats");

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/{table}/Stats")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"

response = http.request(request)
puts response.body

1
2
3
4
5
6
7
8
fetch("{server}/Storage/{appKey}/{table}/Stats", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}"
    }
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/{table}/Stats")
            .addHeader("Authorization", "Bearer {your_access_token}");
        requestBuilder.method("get", null);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/{table}/Stats")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - 响应数据 否
error string 错误信息 否

执行函数☍

接口说明

执行指定的函数

基本信息☍

  • 接口名称：执行函数
  • 请求方式：GET
  • 请求路径：/Storage/{appKey}/ExecuteFunction

请求参数☍

Path 参数☍
参数名 示例值 参数描述 是否必填
appKey - - 是
Query 参数☍
参数名 类型 示例值 参数描述 是否必填
nonce string - 随机字符串 是
timestamp integer - 时间戳 是
signature string - 签名 是
Body 参数☍
参数名 类型 示例值 参数描述 是否必填
functionKey string - 函数标识 否

示例代码☍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;


public class ApiClient {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create("{server}/Storage/{appKey}/ExecuteFunction"))
            .header("Authorization", "Bearer {your_access_token}")
            .header("Content-Type", "application/json");



        // 创建请求体数据
        Map<String, Object> data = {
    "functionKey": ""          // 函数标识
};
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(data);
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), jsonBody);

        requestBuilder.method("get", HttpRequest.BodyPublishers.ofString(jsonBody));

        try {
            HttpResponse<String> response = client.send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import requests

url = "{server}/Storage/{appKey}/ExecuteFunction"
headers = {
    "Authorization": "Bearer {your_access_token}",
    "Content-Type": "application/json"
}


data = {
    "functionKey": ""          // 函数标识
}

response = requests.get(
    url,
    headers=headers,
    json=data
)

print(response.json())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "bytes"
    "encoding/json"
)

func main() {
    client := &http.Client{}

    var req *http.Request
    var err error


    data := {
    "functionKey": ""          // 函数标识
}
    jsonBody, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    req, err = http.NewRequest("get", "{server}/Storage/{appKey}/ExecuteFunction", bytes.NewBuffer(jsonBody))
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/json")

    req.Header.Add("Authorization", "Bearer {your_access_token}")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const axios = require('axios');


const data = {
    "functionKey": ""          // 函数标识
};

const config = {
    method: 'get',
    url: '{server}/Storage/{appKey}/ExecuteFunction',
    headers: {
        'Authorization': 'Bearer {your_access_token}',
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => {
        console.log(response.data);
    })
    .catch(error => {
        console.error(error);
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php

$url = "{server}/Storage/{appKey}/ExecuteFunction";
$headers = [
    "Authorization: Bearer {your_access_token}",
    "Content-Type: application/json"
];


$data = {
    "functionKey": ""          // 函数标识
};

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "get");
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
curl_close($ch);

echo $response;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer {your_access_token}");

            HttpResponseMessage response;


            var data = {
    "functionKey": ""          // 函数标识
};
            var content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json");
            response = await client.getAsync("{server}/Storage/{appKey}/ExecuteFunction", content);

            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
require 'net/http'
require 'json'

uri = URI("{server}/Storage/{appKey}/ExecuteFunction")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::undefined.new(uri)
request["Authorization"] = "Bearer {your_access_token}"
request["Content-Type"] = "application/json"


data = {
    "functionKey": ""          // 函数标识
}
request.set_form_data(data)

response = http.request(request)
puts response.body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
const data = {
    "functionKey": ""          // 函数标识
};

fetch("{server}/Storage/{appKey}/ExecuteFunction", {
    method: "get",
    headers: {
        "Authorization": "Bearer {your_access_token}",
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.catch(error => console.error(error));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.json.JSONObject;


public class ApiClient {
    private final OkHttpClient client = new OkHttpClient();

    public void makeRequest() {
        Request.Builder requestBuilder = new Request.Builder()
            .url("{server}/Storage/{appKey}/ExecuteFunction")
            .addHeader("Authorization", "Bearer {your_access_token}")
            .addHeader("Content-Type", "application/json");


        JSONObject data = {
    "functionKey": ""          // 函数标识
};
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"), data.toString());

        requestBuilder.method("get", body);

        try (Response response = client.newCall(requestBuilder.build()).execute()) {
            System.out.println(response.body().string());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import Foundation

let url = URL(string: "{server}/Storage/{appKey}/ExecuteFunction")!
var request = URLRequest(url: url)
request.httpMethod = "get"
request.setValue("Bearer {your_access_token}", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")


let data = {
    "functionKey": ""          // 函数标识
}
let jsonData = try? JSONSerialization.data(withJSONObject: data)
request.httpBody = jsonData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data) {
            print(json)
        }
    }
}
task.resume()

返回结果☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - 响应数据 否
error string 错误信息 否

数据结构☍

BooleanApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": false          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data boolean 响应数据 否
error string 错误信息 否

ExecuteFunctionRequest☍

1
2
3
{
    "functionKey": ""          // 函数标识
}
字段名 类型 描述 是否必填
functionKey string 函数标识 否

Int64ApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": "0"          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data integer 响应数据 否
error string 错误信息 否

ObjectApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - 响应数据 否
error string 错误信息 否

ObjectListApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": []          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

PostIndexRequest☍

1
2
3
4
{
    "model": {},
    "options": {}
}
字段名 类型 描述 是否必填
model object - 是
options object - 否

StorageListResult☍

1
2
3
4
5
6
7
{
    "take": "0",
    "skip": "0",
    "total": "0",
    "data": null,
    "explain": null
}
字段名 类型 描述 是否必填
take integer - 否
skip integer - 否
total integer - 否
data - - 否
explain - - 否

StorageListResultApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": null,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data - - 否
error string 错误信息 否

StringApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": ""          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data string 响应数据 否
error string 错误信息 否

StringListApiResponse☍

1
2
3
4
5
{
    "code": 200          // 状态码,
    "data": []          // 响应数据,
    "error": ""          // 错误信息
}
字段名 类型 描述 是否必填
code integer 状态码 否
data array 响应数据 否
error string 错误信息 否

通用错误码☍

错误码 说明
200 成功