Zoho Analytics API
Zoho Analytics API 提供了许多功能以帮助开发人员根据其业务应用需求构建和管理功能强大的报告和分析功能。您可以为您的产品/应用程序添加强大的商业智能功能、构建附加组件以分析来自您使用的第三方业务应用程序（例如，Google Ad-words、Google Analytics、CRM 系统等）的数据等等。实际上，许多 Zoho 应用程序（
我们提供了易于使用的编程语言包装器（称为“客户端库”），可以方便地在您熟悉的编程语言（例如，Java、C＃、Python、PHP、GO 和 Google Applications）中使用 Zoho Analytics API。
先决条件
在所有 API 请求（而不是 HTTP 请求）中，必须使用 HTTPS。HTTP 不受支持
始终将
https://analyticsapi.zoho.com 用作 API 请求 URL。
以下是使用 Zoho Analytics API 的先决条件。
Note:
- Zoho Analytics 以前称为 Zoho Analytics。
- API 请求 URL 已从
https://reportsapi.zoho.com 更改为https://analyticsapi.zoho.com 。
Zoho Analytics 用户帐户
用户应该具有有效 Zoho 登录电子邮件地址以使用此 API。如果您没有此地址，请
身份验证令牌
示例响应：
The following is a sample response for a Auth Token request.
#
#Wed Jun 29 03:07:33 PST 2013
AUTHTOKEN=************
RESULT=TRUE
响应详细信息：
* #-COMMENT Auth Token generated date.
* AUTHTOKEN The permanent Auth Token (Alpha numeric value) generated for
Zoho Analytics API access.
* RESULT Value is TRUE if the Auth Token is generated successfully.
身份验证令牌是认证用户以访问其 Zoho 帐户的唯一令牌。这是特定于用户的永久令牌，需要随每个 Zoho Analytics API 请求传递。
生成身份验证令牌
用户可使用下列其中一种方式生成身份验证令牌。您只需生成一次就可对所有 API 调用使用。
- 浏览器模式
- API 模式
浏览器模式
要通过您的浏览器生成身份验证令牌，请遵循以下步骤：
- 登录您的 Zoho Analytics 帐户。
- 在同一浏览器中打开新页签并访问以下 URL。
https://accounts.zoho.com/apiauthtoken/create?SCOPE=ZohoReports/reportsapi
API 模式
要使用 API 方式生成身份验证令牌，请使用以下 URL 格式向 Zoho 帐户发送身份验证请求。
https://accounts.zoho.com/apiauthtoken/nb/create?SCOPE=ZohoReports/reportsapi&EMAIL_ID=emailId&PASSWORD=password
要随此 URL 传递的必需“POST”参数为：
| 参数 | 描述 |
|---|---|
| EMAIL_ID | 指定您的 Zoho 登录电子邮件地址 |
| PASSWORD | 指定您的 Zoho Analytics 密码 （ Note: 如果您正在使用双重身份验证，那么必须提供特定于应用程序的密码。阅读以下注释以了解如何生成此项） |
注释（适用于使用双重身份验证的用户）：
如果您已对您的 Zoho 帐户启用双重身份验证 (TFA)，那么您需要指定特定于应用程序的密码（而不是您的 Zoho Analytics 帐户密码）来生成身份验证令牌。
以下步骤用于为您的 Zoho 帐户生成特定于应用程序的密码。
- 登录
Zoho 帐户 。 - 点击双重身份验证。这将打开设置页面中的双重身份验证部分。
- 点击管理特定于应用程序的密码按钮。
- 在设备（或）应用名称字段中指定描述性名称。例如，Zoho Analytics API。此设备（或）应用名称仅供参考。
- 指定您的 Zoho Analytics 帐户密码。
- 点击生成。这将生成特定于应用程序的密码。
使用此特定于应用程序的密码来为您的帐户生成身份验证令牌。点击此处以了解有关
管理身份验证令牌
您可通过“Zoho 帐户”页面访问和管理您的 Zoho 帐户的所有生效密钥身份验证令牌。
要访问生效身份验证令牌，请执行以下操作：
- 登录 Zoho Analytics。
- 点击右上角随用户名显示的下拉菜单。
- 点击帐户设置菜单项，这将打开 Zoho 帐户个人档案页面（您还可直接使用直接链接
https://accounts.zoho.com 来访问/打开此页面）。 - 导航至设置页签，然后点击生效身份验证令牌。生效身份验证令牌页面将列示您的帐户的生效密钥身份验证令牌。
- 必要时，可分别使用移除和重新生成按钮来移除或重新生成此身份验证令牌。
重要提示
- 身份验证令牌是特定于服务的令牌，不能在 Zoho 服务之间交换（例如，针对 Zoho Analytics 生成的身份验证令牌不能用于 Zoho CRM 之类的另一服务，反之亦然）。
- 生成单一身份验证令牌并将其用于 Zoho Analytics 中的所有 API 调用。
- 如果用户已移除或重新生成身份验证令牌，那么现有令牌将变为无效，并且不能用于 API 请求。
- 如果用户被停用，那么该用户帐户的所有身份验证令牌将变为无效。
- Google Apps 用户可登录您的 Zoho Analytics 帐户并使用浏览器方式生成身份验证令牌。
报告工作空间
要使用 Zoho Analytics API，用户应该已经使用所提供的基于浏览器的 Web 界面在 Zoho Analytics 服务中创建了包含所需表和报告的报告工作空间。如果您的 Zoho Analytics 帐户中没有任何报告工作空间，那么您不能使用该 API。要了解如何创建工作空间，请
API 规范
Zoho Analytics API 使用 HTTP 作为底层传输协议。它基于
- 可以使用 URL 以唯一方式标识 Zoho Analytics 工作空间中的每个表、报告或统计图表。
- 可以使用 URL 中的参数指定要对表/报告/统计图表执行的操作。
- 执行操作所需的额外有效内容也应指定为 URL 中的参数。
- 每个请求都有一个响应，其格式可以使用请求 URL 中的参数进行控制。
在引用实际 API 方法之前，必须清晰了解 API 规范。
请求格式
样本请求：
The below URL adds a row in the table.
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?
ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
authtoken=************&ZOHO_API_VERSION=1.0&Name=Gary
&Date Of Birth=12-Jun-1980&Country=USA&Salary=10000
所有 API 请求应作为 HTTPS POST 请求放置。此请求包含以下元素：
URI（通用资源标识，通常称为 URL）
URL 中作为查询字符串发送的常规必需参数
通过 POST 请求主体发送的参数。
URI
URI 指向 Zoho Analytics 内要对其执行操作的资源。
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
它包含以下部分：
基本 URL
https://analyticsapi.zoho.com/apiEmail Address：此项应该是工作空间的所有者的 Zoho 登录电子邮件地址（例如，abc@zoho.com）WorkspaceName：此项应该是要对其执行 API 的工作空间的名称。（例如，EmployeeDB）TableName：要对其执行操作的视图的名称（表、报告、查询表或统计图表的名称）。（例如，EmployeeDetails）
要在查询字符串中传递的参数
以下代码片段显示应作为查询字符串随以上所定义 URI 传递的常规参数：
<URI>?ZOHO_ACTION=[IMPORT/EXPORT...]&ZOHO_OUTPUT_FORMAT=[XML/JSON/PDF/...]&ZOHO_ERROR_FORMAT=[XML/JSON]&authtoken=<your auth token>&ZOHO_API_VERSION=1.0
“ZOHO_ACTION”之类的控制参数是必需的，必须作为 URL 中的查询字符串的一部分发送。请参阅“常规参数”文档以了解有关可在查询字符串中传递的可能参数的更多令牌。
要通过 POST 请求主体传递的参数
除了在查询字符串中传递的参数之外，特定操作所需的其他信息（例如，“添加行”操作中的行值等等）需要作为 POST 参数传递
<param>1=<value>1&<param2>=<value2>....
参数应以 application/x-www-form-urlencoded 格式编写（这是任何简单 html 表单使用的默认格式）。
Note: 导入 csv 文件时，应使用 multipart/form-data 格式。（这是包含用于上传文件的文件类型字段的 html 表单使用的默认格式）
响应格式
样本响应：对于 ADDROW
Sample response to a request adding a row to the table.
XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDROW">
<result>
<!-- All the columns in the row , including formula columns -->
<row>
<column name="Name">Gary</column>
<column name="Date Of Birth">12-Jun-1980</column>
<column name="Basic">10000</column>
<column name="Country">USA</column>
</row>
</result>
<response>
JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "ADDROW",
"result":
{
"column_order":["Name","Date Of Birth","Salary","Country"],
"rows":
["Gary","12-Jun-1980",10000,"USA"]
}
}
}
API 请求的响应格式由请求中传递的 ZOHO_OUTPUT_FORMAT 查询参数控制。目前，Zoho Analytics 支持 XML 和 JSON 响应格式。仅
Note: 请参阅此
XML 格式
响应会将 <response> 标记作为根节点。它可能包含 <result> 或 <error> 节点作为子代，但不会同时包含两者。常规情况下会出现 <result> 节点，发生错误时将出现 <error> 节点。
格式
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="<specifiedaction>">
<result>
[specific XML response based on action]
</result>
</response>
JSON 格式
JSON 格式与 XML 格式遵循同一模式。
格式
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "<specified action>",
"result": {[action specific properties]}
}
}
其他格式
仅当 ZOHO_ACTION 为
错误处理
样本错误响应：IMPORT DATA
Sample error response for import data in Table.
XML 格式：
<?xml version="1.0" encoding="UTF-8"?>
<response url="/api/EmailAddress/WorkspaceName/TableName" action="IMPORT">
<error>
<code>7138</code>
<message>
Table "TableName" is not present in the workspace "WorkspaceName"
</message>
</error>
</response>
JSON 格式：
{
"response":
{
"url": "/api/EmailAddress/WorkspaceName/TableName",
"action": "IMPORT",
"error":
{
"code":7138,
"message": "Table "TableName" is not present in the workspace "WorkspaceName""
}
}
}
API 执行可能导致错误情况。在这类情况下，您可遵循以下步骤以确定错误情况并进行处理：
检查 http 响应代码。如果为 4xx 或 5xx（例如，400、500、401 等等），那么表示这是一个错误。
发生错误时，错误信息将在响应主体中发送。
错误内容的格式可由参数 ZOHO_ERROR_FORMAT 指定。值可为：
XML
JSON
XML 格式
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="<specifiedaction>">
<error>
[error details]
</error>
</response>
JSON 格式
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "<specified action>",
"error": {[error details]}
}
}
API URL 的查询字符串中的常规参数
在本节中，我们将讨论可以在每个 API 调用的查询字符串中传递的必需参数和可选参数。
必需参数：
身份验证令牌
身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。这相当于通过浏览器登录 Zoho 服务。
ZOHO_ACTION
此参数指定 API 请求要执行的操作。样本值为：
ADDROW - 在表中添加一行数据。IMPORT - 以 CSV/TSV/表格文本格式在表中成批添加数据UPDATE - 更新现有表行。DELETE - 删除表行。EXPORT - 以不同格式导出表或报告。DATABASEMETADATA - 获取有关 Zoho Analytics 帐户中的工作空间以及在其中创建的报告的信息。
Note: ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。
ZOHO_OUTPUT_FORMAT
此参数指定响应的输出格式。以下是受支持的格式：
- XML
- JSON
如果 ZOHO_ACTION 为
- CSV
- HTML
- IMAGE
ZOHO_ERROR_FORMAT
如果尝试处理请求时发生错误，请指定响应的输出格式。以下是受支持的格式：
- XML
- JSON
ZOHO_API_VERSION
编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0
可选参数：
这些参数必须在 POST 请求主体中发送。
ZOHO_DATE_FORMAT
可在
示例：ZOHO_DATE_FORMAT=dd-MMM-yyyy
查看此
数据 API
本节列示一些 API，它们可用于在 Zoho Analytics 数据表中执行添加数据、批量导入、删除和更新操作。本节还提供一些 API 以便使用 PDF、Excel、JSON、HTML、图像和 CSV 格式导出表、报告和统计图表。
添加行
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void addRow(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
Dictionary<string, string> ColumnValues = new Dictionary
<string, string>();
ColumnValues.Add("Region", "South");
Dictionary<string, string> addRowRes = RepClient.AddRow(tableURI,
ColumnValues, config);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.addRow(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func addrow() {
url := reportclient.GetUri(email, dbname, tbname)
columnvalues := map[string]string{}
columnvalues["Id"] = "999"
columnvalues["Name"] = "zzz"
resultmap , err := reportclient.AddRow(url, columnvalues)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(resultmap)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
addrow()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
Map colval = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void addrow() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
colval.put("Id", 101);
colval.put("Name", "sam");
Map result = rc.addRow(uri,colval,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.addrow();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$column_values = array("Employee Name" => "Shankar", "Employee ID" =>
"2015", "Experience" => "5");
$response_array = $report_client_request->addRow($uri, $column_values);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def AddRow(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
rowData = {"Date":"01 Jan, 2009 00:00:00","Region":"East","Product
Category": "Samples","Product":"SampleProduct","Customer Name":
"Sample", "Sales":2000,"Cost":2000}
result = rc.addRow(uri,rowData,None)
print result
obj = Sample()
obj.AddRow(obj.rc)
curl -d "ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************&Id=999
&Name=Gary&Date Of Birth=12-Jun-1980&Salary=10000&Country=USA"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 JSON 格式：
{
"response":
{
"url": "/api/EmailAddress/WorkspaceName/TableName",
"action": "ADDROW",
"result":
{
"column_order":["Name","Date Of Birth","Salary","Country"],
"rows":["Gary","12-Jun-1980",10000,"USA"]
}
}
}
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response url ="/api/EmailAddress/WorkspaceName/TableName"action="ADDROW">
<result>
<!-- All the columns in the row , including formula columns -->
<row>
<column name="Name">Gary</column>
<column name="Date Of Birth">12-Jun-1980</column>
<column name="Basic">10000</column>
<column name="Country">USA</column>
</row>
</result>
</response>
此 API 允许您在指定表中添加一行。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDROW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ColumnName1=Value1&ColumnName2=Value2&ColumnName3=Value3&ColumnName4=Value4
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ADDROW | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数（该行的数据）
该行的列值应作为 POST 参数以 <columnname>=<value> 格式传递。（这些参数应使用 application/x-www-form-urlencoded 格式）。
<columnname> - 它是指要添加值的表列的名称。
<value> - 它是指要对此列添加的对应值。
ADDROW 中的可能错误代码
删除数据
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void deleteRow(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
string criteria = "\"Region\"='South'";
RepClient.DeleteData(tableURI, criteria, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.deleteRow(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
authtoken = "************"
)
func deletedata() {
url := reportclient.GetUri("Email Address", "Workspace Name", "Table Name")
params := map[string]string{}
params["ZOHO_CRITERIA"] = "Id=2"
resp,err := reportclient.DeleteData(url, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(resp)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
deletedata()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void deletedata() throws Exception
{
String uri = rc.getURI("Email Address","Workspace Name","Table Name");
String criteria = "No=12";
Long result = rc.deleteData(uri,criteria,null);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.deletedata();
}
}
<?php
require 'ReportClient.php';
$AUTHTOKEN = "************";
$request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI("Email Address", "Workspace Name", "Table Name");
$criteria = "Experience = 3";
$resp = $request->deleteData($uri ,$criteria);
print_r($resp);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def DeleteData(self,rc):
uri = rc.getURI("Email Address","Workspace Name","Table Name")
criteria = "No=1001"
result = rc.deleteData(uri,criteria,None);
print result
obj = Sample()
obj.DeleteData(obj.rc)
curl -d "ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_CRITERIA=("Department" = 'Finance')"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "DELETE",
"criteria": "\"Department\" = \'Finance\'",
"result":
{
"message": "Deleted rows",
"deletedrows":"4"
}
}
}
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="DELETE">
<criteria>"Department" = 'Finance'</criteria>
<result>
<message>Deleted rows</message>
<deletedrows>4</deletedrows>
</result>
</response>
可使用此 API 删除表中的数据。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_CRITERIA=("ColumnName1"='CriteriaValue1' and "ColumnName2"='CriteriaValue2')
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DELETE | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_CRITERIA （可选） |
条件 | 如果未发送该参数，那么所有行会被删除。如果发送该条件，那么只会删除符合该条件的行。有关 ZOHO_CRITERIA 的格式的更多详细信息，请 |
| ZOHO_VALID_JSON | true / false | 默认情况下，它将为 false。 True - 返回有效 JSON 数据（带有 JSON 转义） False - 返回 JSON 数据（带有 JS 转义）。 |
DELETE DATA 中的可能错误代码
更新数据
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void updateRow(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
Dictionary<string, string> ColumnValues = new Dictionary
<string, string>();
ColumnValues.Add("Region", "North");
string criteria = "\"Region\"='South'";
RepClient.UpdateData(tableURI, ColumnValues, criteria, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.updateRow(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
authtoken = "************"
)
func updatedata() {
url := reportclient.GetUri("Email Address", "Workspace Name", "Table Name")
params := map[string]string{}
params["Salary"] = "100"
params["ZOHO_CRITERIA"] = "Id=1"
resp,err := reportclient.UpdateData(url, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(resp)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
updatedata()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void updatedata() throws Exception
{
String uri = rc.getURI("Email Address","Workspace Name","Table Name");
Map colval = new HashMap();
colval.put("Salary", 1000);
String criteria = "Age=55";
Long result = rc.updateData(uri,colval,criteria,null);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.updatedata();
}
}
<?php
require 'ReportClient.php';
$AUTHTOKEN = "************";
$request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI("Email Address", "Workspace Name", "Table Name");
$column_values = array("Salary" => "10000");
$criteria = "Experience = 2";
$resp = $request->updateData($uri ,$column_values, $criteria);
print_r($resp);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def updateData(self,rc):
uri = rc.getURI("Email Address","Workspace Name","Table Name")
updateInfo = {"Region":"West","Product":"SampleProduct_2"}
criteria = "No=1000"
result = rc.updateData(uri,updateInfo,criteria,None)
print result
obj = Sample()
obj.updateData(obj.rc)
curl -d "ZOHO_ACTION=UPDATE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************&Name=as
&ZOHO_CRITERIA=("Department" = 'Finance')"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "UPDATE",
"criteria": "\"Department\" = 'Finance'",
"result":
{
"updatedColumns":["Salary","Deduction","Perks"],
"updatedRows":"4"
}
}
}
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="UPDATE">
<criteria>"Department" = 'Finance'</criteria>
<result>
<updatedColumns>
<column>Salary</column>
<column>Deduction</column>
<column>Perks</column>
</updatedColumns>
<updatedRows>4</updatedRows>
</result>
</response>
可使用此 API 更新表中的数据。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=UPDATE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ColumnName1=Value1&ColumnName2=Value2&ZOHO_CRITERIA=("ColumnName1"='CriteriaValue1')
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | UPDATE | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_CRITERIA （可选） |
条件 | 如果未发送该参数，那么所有行会被更新。如果发送该条件，那么只会更新符合该条件的行。有关该条件的格式的更多详细信息，请 |
| ZOHO_VALID_JSON | true / false | 默认情况下，它将为 false。 True - 返回有效 JSON 数据（带有 JSON 转义） False - 返回 JSON 数据（带有 JS 转义）。 |
指定要更新的数据（POST 参数）
以 <columnname>=<value> 格式传递您要更新其值的列。（这些参数应使用 application/x-www-form-urlencoded 格式）。
<columnname> - 它是指要更新其值的表列的名称。
<value> - 它是指要在该列中更新的对应值
要指定空 (null) 值，在发送该参数时应带上空值。在以上示例中，Deduction 值设置为空。
UPDATE DATA 中的可能错误代码
导入数据
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void importData(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
Dictionary<string, string> ImportConfig = new Dictionary
<string, string>();
ImportConfig.Add("ZOHO_ON_IMPORT_ERROR", "ABORT");
ImportConfig.Add("ZOHO_CREATE_TABLE", "TRUE");
ImportConfig.Add("ZOHO_AUTO_IDENTIFY", "TRUE");
Dictionary<string, string> ImportRes = RepClient.ImportData(
tableURI, ZohoReportsConstants.APPEND, "C:\\workspace\\mydata.csv", ImportConfig);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.importData(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func importdata() {
url := reportclient.GetUri(email, dbname, tbname)
params := map[string]string{}
file := "/home/sample.csv"
importtype := "APPEND"
autoidentity := "true"
onerror := "ABORT"
resp , err := reportclient.ImportData(url, file, importtype,
autoidentity, onerror, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(resp.ImportErrors)
fmt.Println(resp.ColumnDetails)
fmt.Println(resp.ImportType)
fmt.Println(resp.Warnings)
fmt.Println(resp.SelectedColumnCount)
fmt.Println(resp.SuccessRowCount)
fmt.Println(resp.ImportOperation)
fmt.Println(resp.TotalColumnCount)
fmt.Println(resp.TotalRowCount)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
importdata()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
File csvFile = new File("samples/StoreSales.csv");
private ReportClient rc = new ReportClient(authtoken);
public void importdata() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
config.put("ZOHO_AUTO_IDENTIFY","true");
config.put("ZOHO_ON_IMPORT_ERROR","ABORT");
config.put("ZOHO_CREATE_TABLE","false");
Object result = rc.importData(uri,"APPEND",csvFile,config,false);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.importdata();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "abc@zoho.com";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$import_type = "APPEND";
$file = 'files/Sample.csv';
$auto_identify = "TRUE";
$on_error = "ABORT";
$response_obj = $report_client->importData($table_uri, $import_type, $file,
$auto_identify, $on_error);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="abc@zoho.com"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def importData(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
try:
with open('StoreSales.csv', 'r') as f:
importContent = f.read()
except Exception,e:
print "Error Check if file StoreSales.csv exists in
the current directory"
print "(" + str(e) + ")"
return
impResult = rc.importData(uri,"APPEND",importContent,None)
print "Added Rows :" +str(impResult.successRowCount) + " and Columns :"
+ str(impResult.selectedColCount)
obj = Sample()
obj.importData(obj.rc)
curl -XPOST
'https://analyticsapi.zoho.com/api/UserEmail/WorkspacName/TableName?
ZOHO_ACTION=IMPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_IMPORT_TYPE=APPEND&
ZOHO_AUTO_IDENTIFY=TRUE&ZOHO_ON_IMPORT_ERROR=ABORT&ZOHO_CREATE_TABLE=true'
-H 'content-type: multipart/form-data'
-F 'ZOHO_FILE=@/home/local/import.csv'
样本响应 JSON 格式：
{
" response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "IMPORT",
"result":
{
"importSummary":
{
"totalColumnCount":3,
"selectedColumnCount":3,
"totalRowCount":50,
"successRowCount":48,
"warnings":0,
"importOperation": "created",
"importType": "APPEND"
},
"columnDetails":
{
"Name": "Plain Text",
"Date Of Birth": "Date",
"Salary": "Number"
},
"importErrors": "[Line: 5 Field: 3] a1213 -WARNING: Invalid
Number value"
}
}
}
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="IMPORT">
<result>
<importSummary>
<totalColumnCount>3 </totalColumnCount>
<selectedColumnCount>3</selectedColumnCount>
<totalRowCount>50</totalRowCount>
<successRowCount>48</successRowCount>
<warnings>0</warnings>
<importOperation>created</importOperation>
<importType>APPEND</importType>
</importSummary>
<columnDetails>
<column datatype="Plain Text">Name </column>
<column datatype="Date">Date Of Birth</column>
<column datatype="Number">Salary</column>
</columnDetails>
<!-- The first 100 errors are alone sent -->
<importErrors>
[Line: 5 Field: 3] a1213 -WARNING: Invalid Number value
</importErrors>
</result>
</response>
通过 Zoho Analytics API，您可以批量添加/更新数据。要添加/更新的数据应为 CSV 或 JSON 文件格式。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=IMPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_IMPORT_TYPE=APPEND&ZOHO_AUTO_IDENTIFY=TRUE&ZOHO_ON_IMPORT_ERROR=ABORT&ZOHO_CREATE_TABLE=TRUE&ZOHO_FILE=SampleFiles/Test.csv
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | IMPORT | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_CRITERIA （可选） |
条件 | 如果未发送该参数，那么所有行会被更新。如果已发送条件，那么与该条件相匹配的行将更新。 |
| ZOHO_FILE 或 ZOHO_IMPORT_DATA （必需） |
文件或字符串 | ZOHO_FILE - 要导入的文件。 ZOHO_IMPORT_DATA - 要导入的字符串。 |
| ZOHO_IMPORT_FILETYPE （可选） |
CSV/JSON | 默认值为 CSV。要导入的文件的格式。受支持的格式包括： |
| ZOHO_IMPORT_TYPE （必需） |
APPEND/TRUNCATEADD/UPDATEADD | |
| ZOHO_AUTO_IDENTIFY （必需） |
TRUE/FALSE | 用于指定是否自动标识 CSV 格式。 |
| ZOHO_ON_IMPORT_ERROR （必需） |
ABORT/SKIPROW/SETCOLUMNEMPTY | 此参数控制导入期间发生错误时要执行的操作。 |
| ZOHO_CREATE_TABLE （可选） |
true/false。 | 默认值为 false。 |
| ZOHO_SELECTED_COLUMNS （可选） |
列名的逗号分隔列表。 E.g.,: Name, Department |
指定要从上传数据导入至 Zoho Analytics 表的列。 Note: 对于 JSON 文件，您需要指定列名以捕获完整 JSON 树型结构，例如，employee.Name, employee.Department |
| ZOHO_MATCHING_COLUMNS （仅当 ZOHO_IMPORT_TYPE 为 UPDATEADD 时必需） |
列名的逗号分隔列表。 E.g.,: Name,Department |
要匹配的列中的值将用于比较，以检查要导入的数据行是否与表中的现有行匹配。 表中匹配的现有行将更新为所导入数据中的值。余下行将作为新行附加至该表。 |
| ZOHO_SKIPTOP （可选） |
<number> |
在要导入的 CSV 文件中从头开始跳过的行数。 |
| ZOHO_THOUSAND_SEPARATOR （可选） |
0 / 1 / 2 / 3 | 默认值为 0。 此参数控制数据中有千位分隔符时要执行的操作。 0 - 逗号 1 - 点 2 - 空格 3 - 单引号 |
| ZOHO_DECIMAL_SEPARATOR （可选） |
0 / 1 | 默认值为 0。 此参数控制数据中有小数分隔符时要执行的操作。 0 - 点 1 - 逗号 |
| ZOHO_DATE_FORMAT （可选） |
日期格式。 E.g. dd-MMM-YYYY |
日期值的格式。如果 Zoho Analytics 无法识别要导入的任何日期字段及其格式，请指定此项。 |
| ZOHO_IMPORT_JSON_RETCOLNAMES （可选） |
true/false。 | 默认值为 false。 此参数仅在导入 JSON 文件时适用。它定义如何通过 JSON 文件构造列名。 eg.， employee.Name, employee.Department |
CSV 格式详细信息
如果 ZOHO_AUTO_IDENTIFY 设置为 false，那么需要指定这些参数。
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COMMENTCHAR | <character> |
注释字符。如果在行的开头发现所述字符，那么该 CSV 行将被跳过。 |
| ZOHO_DELIMITER | 0 / 1 / 2 / 3 | 此分隔符用于在文件中分隔多个值。 0 - 分隔符为逗号 1 - 分隔符为制表符 2 - 分隔符为分号 3 - 分隔符为空格 |
| ZOHO_QUOTED | 0 / 1 / 2 | 文本限定符。 0 - 无 1 - 单引号 2 - 双引号 |
IMPORT DATA 中的可能错误代码
导出数据
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public object export(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
Dictionary<string, object> resObj = RepClient.
ExportDataAsDictionary(tableURI, "\"Region\"
='West'", null);
Object[] columns = (Object[])resObj["column_order"];
Object[] rows = (Object[])resObj["rows"];
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.export(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func exportdata() {
url := reportclient.GetUri(email, dbname, tbname)
outputformat := "pdf"
filename := "sample"
params := map[string]string{}
err := reportclient.ExportData(url, filename, outputformat, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
exportdata()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
File csvFile = new File("samples/StoreSales.csv");
private ReportClient rc = new ReportClient(authtoken);
public void exportdata() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.exportData(uri,"CSV",csvFile,null,null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.exportdata();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$output_format = "CSV";
$criteria = "Salary = 5000";
$report_client_response = $report_client_request->exportData($uri,
$output_format);
$file = "dummy/".$TABLE_NAME.".".$output_format;
file_put_contents($file, $report_client_response, FILE_APPEND);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Employee"
TABLENAME="Employee"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def exportdata(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
fileobj = open("/home/sample.csv","rw+")
rc.exportData(uri,"CSV",fileobj)
fileobj.close()
obj = Sample()
obj.exportdata(obj.rc)
curl -d "ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "EXPORT",
"result":
{
"column_order":["Name","Department","Date Of Birth"],
"rows":
[
["John","Finance","12 May 1972"],
["Joan","Admin","15 June 1975"]
]
}
}
}
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="EXPORT">
<result>
<rows>
<row>
<column name="Name">Gary</column>
<column name="Date Of Birth">12-Jun-1980</column>
<column name="Basic">10000</column>
<column name="Country">USA</column>
</row>
<row>
<column name="Name">John</column>
<column name="Date Of Birth">12-Jun-1981</column>
<column name="Basic">10000</column>
<column name="Country">Canada</column>
</row>
<row>
<column name="Name">Joan</column>
<column name="Date Of Birth">12-Jun-1982</column>
<column name="Basic">10000</column>
<column name="Country">Mexico</column>
</row>
</rows>
</result>
</response>
通过使用此 API，用户可以不同格式从表或报告（数据透视表、图表等等）导出/提取数据。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | EXPORT | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON/CSV/PDF/HTML/IMAGE | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_CRITERIA （可选） |
条件 | 如果未发送该参数，那么所有行会被导出。如果发送该条件，那么只会导出符合该条件的行。有关该条件的格式的更多详细信息，请 |
| GENERATETOC （可选 - 仅适用于仪表板） |
true / false | true - 生成目录。默认情况下为 false。 |
| ZOHO_DASHBOARD_LAYOUT （可选 - 仅适用于仪表板） |
0 或 1 | 0 - 每个报告展示在新页面中 1 - 布局与仪表板中一样 |
其他可选参数。
下面定义的所有参数都是可选参数。
CSV 格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_DELIMITER | 0 到 3 之间的值 0 - 逗号 1 - 制表符 2 - 分号 3 - 空格 |
分隔符，用于分隔 CSV 行中的字段。 |
| ZOHO_RECORD_DELIMITER | 0 到 2 之间的值 0 - DOS 1 - UNIX 2 - MAC |
要使用的记录分隔符（换行符）。 |
| ZOHO_QUOTED | 0 到 1 之间的值 0 - 单引号 1 - 双引号 |
用于引用值的引号字符。 |
| ZOHO_INCLUDE_HEADER | true / false | true - 所导出 CSV 的第一行中包含列名。 false - 所导出 CSV 的第一行中不包含列名。 |
| ZOHO_SHOW_HIDDENCOLS | true / false | 控制表/报告中隐藏的列必须导出至的位置。 true - 在所导出数据中包含表/报告的隐藏列。 false - 在所导出数据中不包含表/报告的隐藏列。 |
XML 格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_SHOW_HIDDENCOLS | true / false | 控制表/报告中隐藏的列必须导出至的位置。 true - 在所导出数据中包含表/报告的隐藏列。 false - 在所导出数据中不包含表/报告的隐藏列。 |
HTML 格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_SHOW_HIDDENCOLS | true / false | 控制表/报告中隐藏的列必须导出至的位置。 true - 在所导出数据中包含表/报告的隐藏列。 false - 在所导出数据中不包含表/报告的隐藏列。 |
PDF 格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_PAPERSIZE | 0 到 5 之间的值 0 - LETTER 1 - LEGAL 2 - TABLOID 3 - A3 4 - A4 5 - AUTO |
纸张大小。 |
| ZOHO_SHOW_TITLE | 0 到 2 之间的值 0 - 位于顶部 1 - 位于底部 2 - 无 |
控制标题位置 |
| ZOHO_SHOW_DESC | 0 到 2 之间的值 0 - 位于顶部 1 - 位于底部 2 - 无 |
控制描述位置。 |
| ZOHO_EXPORT_LANGUAGE | 0 到 4 之间的值 0 - 英语 1 - 欧盟语言 2 - 中文 3 - 日语 4 - 韩语 默认 - 英语 |
PDF 将使用所指定语言呈示 |
| ZOHO_PAPERSTYLE | 纵向/横向 | |
| ZOHO_SHOW_HIDDENCOLS | true / false | 控制表/报告中隐藏的列必须导出至的位置。true- 在所导出数据中包含表/报告的隐藏列false - 在所导出数据中不包含表/报告的隐藏列。 |
| ZOHO_SELECTED_COLUMNS | 列名的逗号分隔列表 | 控制需要导出的列名。如果未给出，那么将导出表/报告中的所有列。 |
| 边距设置： | ||
| ZOHO_TOPMARGIN ZOHO_BOTTOMMARGIN ZOHO_LEFTMARGIN ZOHO_RIGHTMARGIN |
0 到 1 之间的小数值 | 边缘的边距（以英寸计）。可为 0 到 1 之间的小数值（例如，0.5）。 |
| 页眉/页脚设置： | ||
| ZOHO_HEAD_LEFT ZOHO_HEAD_RIGHT ZOHO_HEAD_CENTER ZOHO_FOOT_LEFT ZOHO_FOOT_RIGHT ZOHO_FOOT_CENTER |
0 到 5 之间的值 0 - 留为空白 1 - 包含标题 2 - 当前日期/时间 3 - 以“第 # 页”的格式添加页码 4 - 以“第 # 页，共 # 页”的格式添加页码 5 - 自定义 - 在页脚中添加自定义文本 |
需要在特定位置对每页生成的页眉/页脚值。 |
| 自定义页眉/页脚值 | ||
| ZOHO_HEAD_LEFT_TEXT ZOHO_HEAD_RIGHT_TEXT ZOHO_HEAD_CENTER_TEXT ZOHO_FOOT_LEFT_TEXT ZOHO_FOOT_RIGHT_TEXT ZOHO_FOOT_CENTER_TEXT |
自定义文本。 | 如果任意页眉/页脚设置为 5（即，自定义），那么应传递对应自定义值/文本。 |
图像格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_WIDTH | <number> |
图像宽度。 |
| ZOHO_HEIGHT | <number> |
图像高度。 |
| ZOHO_TITLE | true / false | 控制是否将报告标题添加至图像。 true - 包含标题。 false - 不包含标题。 |
| ZOHO_DESCRIPTION | true/false | 控制是否将报告描述添加至图像。 true - 包含描述。 false - 不包含描述。 |
| ZOHO_SHOWLEGEND | true / false | 控制是否在所生成图像中包含图注。 true - 在图像中包含图注。 false - 在图像中不包含图注。 |
| ZOHO_IMAGE_FORMAT | png / jpg | 所导出图像的格式。可为 PNG 或 JPG 格式。 |
JSON 格式
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_VALID_JSON | true / false | 默认情况下，它将为 false。 True - 返回有效 JSON 数据（带有 JSON 转义） False - 返回 JSON 数据（带有 JS 转义）。 |
| ZOHO_SHOW_HIDDENCOLS | true / false | 控制表/报告中隐藏的列必须导出至的位置。 true - 在所导出数据中包含表/报告的隐藏列。 false - 在所导出数据中不包含表/报告的隐藏列。 |
| ZOHO_CALLBACK_FUNCTION | json 回调函数的名称 | 在页面上的 JavaScript 代码中的其他位置处理 JSON 响应 |
示例：JSON 回调。
1. 定义回调函数。
<script>
function sampleFunction(resp)
{
var response = resp.response;
var result = response.result;
var rows = result.rows;
for(i=0;i<rows.length;i++)
{
var row = rows[i];
console.log(row);
// your application code
}
// your application code
}
</script>
2.调用 api 请求并指定输出格式 JSON 和 ZOHO_CALLBACK_FUNCTION=sampleFunction。
<script src="
https://analyticsapi.zoho.com/api/<EmailAddress>/<Workspace>/<Table>
?ZOHO_ACTION=EXPORT&ZOHO_OUTPUT_FORMAT=JSON&ZOHO_ERROR_FORMAT=XML&authtoken=
<your auth token>&ZOHO_API_VERSION=1.0&ZOHO_CALLBACK_FUNCTION=sampleFunction">
</script>
加载页面时，将按以下形式返回响应：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "EXPORT",
"result":
{
"column_order":["Name","Department","Date Of Birth"],
"rows":
[
["John","Finance","12 May 1972"],
["Joan","Admin","15 June 1975"]
]
}
}
}
JSON 回调 - JSONP：
Zoho Analytics API 支持使用回调函数以异步方式处理 API 响应。如果选择 JSON 作为输出格式，那么这在“导出 API”调用中是受支持的。
指定 JSON 作为输出格式的“导出 API”方法调用支持使用附加参数 ZOHO_CALLBACK_FUNCTION 来启用回调。通过使用回调函数，开发者可在 <script> 标记内调用“导出 API”请求，并在页面上的 JavaScript 代码中的其他位置使用 CALLBACK 函数处理 JSON 响应。
使用 SQL 导出：
Zoho Analytics 以 HTTP Web API 扩展的形式实现了 Zoho CloudSQL 技术。通过使用
有关如何使用 SQL SELECT 查询从 Zoho Analytics 获取数据的更多详细信息，请参阅有关
EXPORT DATA 中的可能错误代码
应用过滤条件
示例
(( "Department"='Finance' and "Salary" < 9000) or ("Department"='Admin'
and "Salary" < 8000))
示例
A sample delete request that deletes all the rows that match
the criteria "s2">"Department"='Finance'
is given below.
URL：
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?
ZOHO_ACTION=DELETE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&authtoken=************&ZOHO_API_VERSION=1.0
以 POST 参数形式发送的数据。
ZOHO_CRITERIA=("Department"='Finance')
ZOHO_CRITERIA is encoded for the url format. Unencoded value is provided below.
ZOHO_CRITERIA=("Department"='Finance')
Zoho Analytics API 允许您在执行各种操作时应用过滤条件。应用条件时，仅对与所给定过滤条件相匹配的数据执行操作。
可在以下 API 操作中应用条件：
更新
删除
导出
过滤条件必须以参数 ZOHO_CRITERIA 的形式传递至操作请求。它应该包含在 POST 请求主体中。
格式
在请求中传递的过滤条件应遵循 SQL SELECT WHERE 子句的格式。下面给出简单条件的通用格式：
(<columnname/SQL expression/SQL function calls> <relational operator> <value/column name/SQL expression/SQL function calls>)
描述
该条件遵循类似
| 名称 | 描述 |
|---|---|
| 列名 | 它是指表或查询表中您要对其应用条件的列的名称。 |
| SQL 表达式 | 您可提供任意有效 SQL 表达式。 以上表达式从“Sales”列值减去“Cost”列值。您可在 算术运算符： +、-、* 和 / |
| SQL 函数调用 | Oracle、MS SQL Server、MySQL、DB2、Sybase、ANSI SQL、Informix 和 PostgreSQL 数据库 例如： year(date_column) = 2008。 Note: 后续将讨论不同数据库中的所有受支持内置函数。 |
| 关系运算符 | 它可以是 受支持的关系运算符： |
| 值 | 它是指要匹配的确切值。 例如：“Department” = 'Finance’ 此处 'Finance’ 是要匹配的文字值。 |
条件构造注释：
- 您可使用 AND 和 OR 之类的逻辑运算符组合按以上指定格式定义的任意数目的条件来构成复杂条件，就像在
SQL SELECT WHERE 子句中一样。还可使用括号 ’()’来组合条件以确定顺序。 - 将字符串文字（例如，值）括在单引号中。
将列名括在双引号中。
例如：(“Date Of Birth” = '2007-01-31 00:00:00’)
条件中不能使用货币符号（或）百分比符号
例如，currency_column = 75.66 有效
例如，percent_column = 100 有效
currency_column = 75.66$（或）percent_column = 100% 无效。
有关如何构造过滤条件更多信息，请参阅
“数据 API”中的错误代码
样本错误 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName" action="ADDROW">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "ADDROW",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the workspace exists"
}
}
}
本节列示“数据 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 7103 | API URL 中提到的工作空间名称不存在。 | 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。 |
| 7138 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 7507 | 在所提及列中输入的值未遵循所指定数据类型。 | 检查该列的值并按所指定数据类型提供值。 |
| 7511 | 所提及列为必需列。 | 应对该必需列指定值。 |
| 8002 | 所指定条件无效。 | 请提供有效条件。 |
| 8004 | 条件中所提及列不在该表中。 | 请检查列名并提供有效名称。 |
| 8016 | 对于 INSERT 或 UPDATE 操作，您需要至少一个列。 | 应提供至少一个带有值的列。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
建模 API
本节列示所有建模 API。“建模 API”可用于添加、删除和重命名 Zoho Analytics 表中的列。它还提供了一些 API，用于将对象（工作空间、报告和公式）从一个工作空间复制到同一帐户或不同帐户中的另一个工作空间。
复制工作空间
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void copyDatabase(IReportClient RepClient)
{
string dbURI = RepClient.GetURI(EMAIL, DBNAME);
string newDBName = "newdbname";
string newDBDesc = "dbdesc";
bool withData = true;
string copyDBKey = "************"
long dbid = RepClient.CopyDatabase(dbURI, newDBName, newDBDesc,
withData, copyDBKey, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.copyDatabase(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
dbkey = "************"
)
func copydatabase() {
url := reportclient.GetDbUri(email, dbname)
newdbname := "Sample"
params := map[string]string{}
newid , err := reportclient.CopyDatabase(url, newdbname, dbkey, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(newid)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
copydatabase()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void copydatabase() throws Exception
{
String uri = rc.getURI(email,dbname);
config.put("ZOHO_DATABASE_NAME", "database");
config.put("ZOHO_COPY_DB_KEY", "************");
long result = rc.copyDatabase(uri,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.copydatabase();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$db_key = "************ ";
$db_name = "Workspace Name";
$new_database_id = $report_client_request->copyDatabase($uri, $db_key,
$db_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def CopyDatabase(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
config = {"ZOHO_DATABASE_NAME":"new sales",
"ZOHO_COPY_DB_KEY":"************"}
result = rc.copyDatabase(uri,config)
obj = Sample()
obj.CopyDatabase(obj.rc)
curl -d "ZOHO_ACTION=COPYDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_DATABASE_NAME=New Workspace Name&ZOHO_COPY_DB_KEY=
************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName" action="COPYDATABASE">
<result>
<message>
Successfully Workspace Copied
</message>
<dbid>
99999999999999
</dbid>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress/WorkspaceName",
"action": "COPYDATABASE",
"result":
{
"message": "Successfully Workspace Copied",
"dbid": "99999999999999"
}
}
}
“复制工作空间 API”用于将工作空间从一个 Zoho Analytics 帐户复制到另一个 Zoho Analytics 帐户。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/Workspacename?ZOHO_ACTION=COPYDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DATABASE_NAME=CopiedWorkspace&ZOHO_COPY_DB_KEY=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | COPYDATABASE | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_DATABASE_NAME （必需） |
<Workspace name> |
此参数包含目标工作空间的名称 |
| ZOHO_DATABASE_DESC （可选） |
<Workspace description> |
此参数包含目标工作空间的描述 |
| ZOHO_COPY_WITHDATA （可选） |
true/false | true - 源工作空间的所有表中的数据将复制到目标工作空间。false - 源工作空间的所有表中的数据不会复制到目标工作空间。 |
| ZOHO_COPY_DB_KEY （必需） |
<Workspace key> |
用于允许用户复制工作空间/报告的密钥。 源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。 https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_db_owner_authtoken>&ZOHO_API_VERSION=1.0 .Note: 您需要在以上 URL 中提供相应值，以便为您的设置生成相应的复制工作空间密钥。 |
COPY WORKSPACE 中的可能错误代码
删除工作空间
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void deleteDatabase(IReportClient RepClient)
{
string userURI = RepClient.GetURI(EMAIL);
string databaseName = "Workspace Name";
RepClient.DeleteDatabase(userURI, databaseName, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.deleteDatabase(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func deletedatabase() {
url := reportclient.GetUserUri(email)
dbname := "Workspace Name"
err := reportclient.DeleteDatabase(url, dbname)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
deletedatabase()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void deletedatabase() throws Exception
{
String uri = rc.getURI(email);
rc.deleteDatabase(uri,"database",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.deletedatabase();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$db_name = "Workspace Name";
$report_client_request->deleteDatabase($uri, $db_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def DeleteDatabase(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
databaseName = "WorkspaceName"
rc.deleteDatabase(uri,databaseName)
obj = Sample()
obj.DeleteDatabase(obj.rc)
curl -d "ZOHO_ACTION=DELETEDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_DATABASE_NAME=Workspace Name"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="DELETEDATABASE">
<result>
<message>
Workspace deleted successfully
</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "DELETEDATABASE",
"result":
{
"message": "Workspace deleted successfully"
}
}
}
“删除工作空间 API”用于从您的 Zoho Analytics 帐户中删除工作空间。此 API 将删除调用此 API 的用户帐户中的工作空间，而不删除其他帐户中的工作空间。请注意，如果使用此 API 删除工作空间，那么无法还原相同的工作空间。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DELETEDATABASE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DATABASE_NAME=Workspace Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DELETEDATABASE | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_DATABASE_NAME （必需） |
工作空间名称 | 此参数包含要删除的工作空间的名称 |
DELETE WORKSPACE 中的可能错误代码
启用域工作空间（仅适用于白标客户）
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void enabledomaindb(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL);
string dbname = "Workspace Name";
string domainname = "Domain Name";
var result = rc.EnableDomainDB(uri, dbname, domainname, null);
foreach (KeyValuePair<string, string> kvp in result)
{
Console.WriteLine(kvp.Key + " = " + kvp.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.enabledomaindb(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
authtoken = "************"
)
func EnableDomainDB(){
url := reportclient.GetUserUri("Email Address")
params := map[string]string{}
err := reportclient.EnableDomainDB(url, "Workspace Name", "Domain Name", params)
if(err != nil)
{
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
} else {
fmt.Println("success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
EnableDomainDB()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void enableDomainDB() throws Exception
{
String uri = rc.getURI("Email Address");
String dbName = "Workspace Name";
String domainName = "Domain Name";
rc.enableDomainDB(uri, dbName, domainName, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.enableDomainDB();
}
}
<?php
require 'ReportClient.php';
$AUTHTOKEN = "************";
$request = new ReportClient($AUTHTOKEN);
$uri = $request->getUserURI("Email Address");
$dbname = "Workspace Name";
$domain_name = "Domain Name";
$request->enableDomainDB($uri, $dbname, $domain_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def enableDomainDB(self,rc):
uri = rc.getURI("Email Address")
dbName = "Workspace Name"
domainName = "Domain Name"
rc.enableDomainDB(uri,dbName,domainName)
obj = Sample()
obj.enableDomainDB(obj.rc)
curl -d "ZOHO_ACTION=ENABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&DBNAME=Workspace Name&DOMAINNAME=Domain Name"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="ENABLEDOMAINDB">
<result>
<status>Success</status>
<message>Domain Feature has been enabled</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ENABLEDOMAINDB",
"result":
{
"status":"Success",
"message":"Domain Feature has been enabled"
}
}
}
“启用工作空间 API”用于对白标帐户（自定义域）启用您的 Zoho Analytics 帐户中的工作空间。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ENABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBNAME=Workspace Name&DOMAINNAME=Domain Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ENABLEDOMAINDB | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| DBNAME （必需） |
工作空间名称 | 此参数包含要启用的工作空间的名称。 |
| DOMAINNAME （必需） |
域名 | 此参数包含域地址。 |
ENABLE DOMAIN WORKSPACE 中的可能错误代码
禁用域工作空间（仅适用于白标客户）
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void disabledomaindb(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL);
string dbname = "Workspace Name";
string domainname = "Domain Name";
var result = rc.DisableDomainDB(uri, dbname, domainname, null);
foreach (KeyValuePair<string, string> kvp in result)
{
Console.WriteLine(kvp.Key + " = " + kvp.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.disabledomaindb(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
authtoken = "************"
)
func DisableDomainDB(){
url := reportclient.GetUserUri("Email Address")
params := map[string]string{}
err := reportclient.DisableDomainDB(url, "Workspace Name", "Domain Name", params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
DisableDomainDB()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void disableDomainDB() throws Exception
{
String uri = rc.getURI("Email Address");
String dbName = "Workspace Name";
String domainName = "Domain Name";
rc.disableDomainDB(uri, dbName, domainName, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.disableDomainDB();
}
}
<?php
require 'ReportClient.php';
$AUTHTOKEN = "************";
$request = new ReportClient($AUTHTOKEN);
$uri = $request->getUserURI("Email Address");
$dbname = "Workspace Name";
$domain_name = "Domain Name";
$request->disableDomainDB($uri, $dbname, $domain_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def disableDomainDB(self,rc):
uri = rc.getURI("Email Address")
dbName = "Workspace Name"
domainName = "Domain Name"
rc.disableDomainDB(uri,dbName,domainName)
obj = Sample()
obj.disableDomainDB(obj.rc)
curl -d "ZOHO_ACTION=DISABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&DBNAME=Workspace Name&DOMAINNAME=Domain Name"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="DISABLEDOMAINDB">
<result>
<status>Success</status>
<message>Domain Feature has been disabled</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "DISABLEDOMAINDB",
"result":
{
"status":"Success",
"message":"Domain Feature has been disabled"
}
}
}
“禁用工作空间 API”用于对白标帐户（自定义域）禁用您的 Zoho Analytics 帐户中的工作空间。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DISABLEDOMAINDB&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBNAME=Workspace Name&DOMAINNAME=Domain Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DISABLEDOMAINDB | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| DBNAME （必需） |
工作空间名称 | 此参数包含要禁用的工作空间的名称。 |
| DOMAINNAME （必需） |
域名 | 此参数包含域地址。 |
DISABLE DOMAIN WORKSPACE 中的可能错误代码
创建表
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void createtable(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string tabledesign = "{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\":\
"Testing Purpose\",\"FOLDERNAME\": \"NewFolder\",\
"COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":\
"null\",\"MANDATORY\" : \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}";
rc.CreateTable(uri, tabledesign, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.createtable(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func createtable() {
url := reportclient.GetDbUri(email, dbname)
tableconfig := "{\"TABLENAME\": \"SystemTable\",\"TABLEDESCRIPTION\": \"
Testing Purpose\", \"FOLDERNAME\": \"
NewFolder\",\"COLUMNS\":[{\"COLUMNNAME\": \"Product Category
\",\"DATATYPE\": \"PLAIN\",\"DEFAULT\": \"Test\",\"MANDATORY\" :
\"Yes\",\"DESCRIPTION\" :
\"Testing2\"}]}"
err := reportclient.CreateTable(url, tableconfig)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
createtable()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void createtable() throws Exception
{
String uri = rc.getURI(email,dbname);
String tableDesign = "{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\"
:\"Testing Purpose\",\"FOLDERNAME\": \"NewFolder\",
\"COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":
\"null\",\"MANDATORY\" : \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}"
rc.createTable(uri,tableDesign,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.createtable();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$table_design = '{
"TABLENAME": "SystemTable",
"TABLEDESCRIPTION": "Testing Purpose",
"FOLDERNAME": "NewFolder",
"COLUMNS":
[
{
"COLUMNNAME": "SrNo",
"DATATYPE": "NUMBER",
"DEFAULT": "null",
"MANDATORY" : "Yes",
"DESCRIPTION" : "Testing"
},
{
"COLUMNNAME": "Product",
"DATATYPE": "null",
"DEFAULT": "null",
"MANDATORY" : "Yes",
"DESCRIPTION" : "Testing2"
},
{
"COLUMNNAME": "Product Category",
"DATATYPE": "PLAIN",
"DEFAULT": "Test",
"MANDATORY" : "Yes",
"DESCRIPTION" : "Testing2"
}
]
}';
$report_client_request->createTable($uri, $table_design);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def createtable(self,rc):
uri = rc.getDBURI(Config.LOGINEMAILID,Config.DATABASENAME)
tableDesign ='{\"TABLENAME\":\"SysteTable\",\"TABLEDESCRIPTION\"
:\"Testing Purpose\",FOLDERNAME\": \"NewFolder\",
\"COLUMNS\":[{\"COLUMNNAME\":\"SrNo\",\"DATATYPE\": \"NUMBER\",\"DEFAULT\":
\"null\",\"MANDATORY\" : \"Yes\",\"DESCRIPTION\" : \"Testing\"}]}'
rc.createTable(uri,tableDesign)
obj = Sample()
obj.createtable(obj.rc)
curl -d "ZOHO_ACTION=CREATETABLE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_TABLE_DESIGN="Table Design in JSON""
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="CREATETABLE">
<result>
<message>Table created successfully!</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName",
"action":"CREATETABLE",
"result":
{
"message":"Table created successfully!"
}
}
}
“创建表 API”用于在指定工作空间中创建表。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=CREATETABLE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_TABLE_DESIGN=Table_Design_In_JSON
TABLE DESIGN
{
"TABLENAME": "Table Name",
"TABLEDESCRIPTION":"Table Description",
"FOLDERNAME": "Target Folder",
"COLUMNS":
[
{
"COLUMNNAME":"Column Name 1",
"DATATYPE": "Column DataType",
"DEFAULT":"Default Value",
"MANDATORY" : "Yes/No",
"DESCRIPTION" : "Column Description"
},
{
"COLUMNNAME":"Column Name 2",
"DATATYPE": "Column DataType",
"DEFAULT":"null",
"MANDATORY" : "Yes/No",
"DESCRIPTION" : "Column Description"
}
]
}
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | CREATETABLE | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_TABLE_DESIGN （必需） |
以 JSON 格式设计内容 | JSON 格式的表结构（包含表名、描述、文件夹名称、列和查找详细信息）。 |
CREATE TABLE 中的可能错误代码
自动生成报告
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void autogenreports(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL,DBNAME,TBNAME);
Dictionary<string,string> param = new Dictionary<string,string>();
param.Add("ZOHO_CREATEAGAIN", "true");
string source = "TABLE";
var result = rc.AutoGenReports(uri, source, param);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.autogenreports(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func autogenreports(){
url := reportclient.GetUri(email, dbname, tbname)
source := "TABLE"
params := map[string]string{}
params["ZOHO_COLUMN_NAME"] = "Region"
result , err := reportclient.AutoGenReports(url, source, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
autogenreports()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void autoGenReports() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
String source = "TABLE";
Map result = rc.autoGenReports(uri, source, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.autoGenReports();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$source = "TABLE";
$response = $request->autoGenReports($uri, $source);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def autogenreport(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
source = "TABLE"
result = rc.autoGenReports(uri,source)
print result
obj = Sample()
obj.autogenreport(obj.rc)
curl -d "ZOHO_ACTION=AUTOGENREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_SOURCE=TABLE"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="AUTOGENREPORTS">
<result>
<status>success</status>
<message>Reports generated successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "AUTOGENREPORTS",
"result": {
"status": "success",
"message": "Reports generated successfully"
}
}
}
“自动生成报告 API”用于在 Zoho Analytics 表中生成报告。只有帐户管理员和工作空间管理员才能使用此 API 生成报告。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=AUTOGENREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_SOURCE=TABLE
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | AUTOGENREPORTS | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_SOURCE （必需） |
TABLE/COLUMN | TABLE - 针对特定表生成报告。 COLUMN - 针对特定列生成报告。 |
| ZOHO_CREATEAGAIN （可选） |
true/false | True - 如果之前生成报告，那么将生成重复报告。 False - 如果之前生成报告，那么将抛出错误消息。 |
| ZOHO_COLUMN_NAME （SOURCE 为 COLUMN 时必需） |
columnname | 想要对其生成报告的列名。 |
AUTOGENERATE REPORTS 中的可能错误代码
创建类似视图
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void createsimilarviews(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL, "Workspace name", "Table Name");
string refview = "Reference Table Name";
string foldername = "Folder Name";
string copycusformula = false;
string copyaggformula = false;
var result = rc.CreateSimilarViews(uri, refview, foldername, copycusformula, copyaggformula, null);
foreach (KeyValuePair<string, string> kvp in result)
{
Console.WriteLine(kvp.Key + " = " + kvp.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.createsimilarviews(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "User Email"
authtoken = "************"
)
func CreateSimilarViews(){
url := reportclient.GetUri(email, "Workspace Name", "Table Name")
refview := "Reference Table Name"
foldername := "Folder Name"
customformula := false
aggformula := false
params := map[string]string{}
result , err := reportclient.CreateSimilarViews(url, refview, foldername, customformula, aggformula, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
CreateSimilarViews()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String databaseName = "Workspace Name";
String tableName = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void createSimilarViews() throws Exception
{
String uri = rc.getURI(email,databaseName,tableName);
String refView = "Reference Table Name";
String folderName = "Folder Name";
boolean customFormula = false;
boolean aggFormula = false;
Map result = rc.createSimilarViews(uri, refView, folderName, customFormula, aggFormula, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.createSimilarViews();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$ref_view = "Reference Table Name";
$folder_name = "Folder Name";
$copy_customformula = false;
$copy_aggformula = false;
$response = $request->createSimilarViews($uri, $ref_view, $folder_name, $copy_customformula, $copy_aggformula);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def createSimilarViews(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
refView = "Reference Table Name"
folderName = "Folder Name"
customFormula = False
aggFormula = False
result = rc.createSimilarViews(uri,refView,folderName,customFormula,aggFormula)
obj = Sample()
obj.createSimilarViews(obj.rc)
curl -d "ZOHO_ACTION=CREATESIMILARVIEWS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_REFVIEW=Reference Table Name&ZOHO_FOLDERNAME=Folder Name&ISCOPYCUSTOMFORMULA=false
&ISCOPYAGGFORMULA=false"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="CREATESIMILARVIEWS">
<result>
<status>success</status>
<message>Reports created successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
"action": "CREATESIMILARVIEWS",
"result":
{
"status":"Success",
"message":"Reports created successfully"
}
}
}
“创建类似视图 API”用于通过 Zoho Analytics 表生成报告。这些视图是根据引用表视图创建的。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=CREATESIMILARVIEWS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_REFVIEW=RefTable Name&ZOHO_FOLDERNAME=Folder name&ISCOPYCUSTOMFORMULA=false&ISCOPYAGGFORMULA=false
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | CREATESIMILARVIEWS | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_REFVIEW （必需） |
引用视图名称 | 此参数包含引用视图的名称。 |
| ZOHO_FOLDERNAME （必需） |
目标文件夹名称 | 此参数包含要保存视图的文件夹的名称。 |
| ISCOPYCUSTOMFORMULA （必需） |
True / False | True - 还会在新视图中复制自定义公式。 False - 不会在新视图中处理自定义公式。 |
| ISCOPYAGGFORMULA （必需） |
True / False | True - 还会在新视图中复制汇总公式。 False - 不会在新视图中处理汇总公式。 |
CREATE SIMILAR VIEWS 中的可能错误代码
重命名视图
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void renameview(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string viewname = "Old Name";
string newviewname = "New Name";
string viewdesc = "Description";
rc.RenameView(uri, viewname, newviewname, viewdesc, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.renameview(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func renameview() {
url := reportclient.GetDbUri(email, dbname)
viewname := "Old Name"
newname := "New Name"
newdesc := "Description"
err := reportclient.RenameView(url, viewname, newname, newdesc)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
renameview()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void renameview() throws Exception
{
String uri = rc.getURI(email,dbname);
rc.renameView(uri,"Old Name","New Name","Description",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.renameview();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$view_name = "Old Name";
$new_view_name = "New Name";
$new_view_desc = "Description";
$$report_client_request->renameView($uri, $view_name,
$new_view_name, $new_view_desc);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def renameview(self,rc):
uri = rc.getDBURI(Config.LOGINEMAILID,Config.DATABASENAME)
rc.renameView(uri,"Old Name","New Name","Description")
obj = Sample()
obj.renameview(obj.rc)
curl -d "ZOHO_ACTION=RENAMEVIEW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_VIEWNAME="Old Name"&ZOHO_NEW_VIEWNAME="New Name"&ZOHO_NEW_VIEWDESC="Description""
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="RENAMEVIEW">
<result>
<message>View renamed successfully!</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName",
"action":"RENAMEVIEW",
"result":
{
"message":"View renamed successfully!"
}
}
}
“重命名视图 API”用于使用新名称和描述重命名所指定视图。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=RENAMEVIEW&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_VIEWNAME=Old Name&ZOHO_NEW_VIEWNAME=New Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | RENAMEVIEW | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_VIEWNAME （必需） |
视图名称 | 视图的当前名称 |
| ZOHO_NEW_VIEWNAME （必需） |
新视图名称 | 视图的新名称 |
| ZOHO_NEW_VIEWDESC （可选） |
视图描述 | 视图的新描述 |
RENAME VIEW 中的可能错误代码
复制报告
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void copyreports(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string views = "View1,View2";
string dbname = "Destination Workspace Name";
string dbkey = "************";
rc.CopyReports(uri, views, dbname, dbkey, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.copyreports(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
dbkey = "*************"
)
func copyreports() {
url := reportclient.GetDbUri(email, dbname)
viewnames := "View1,View2"
destdbname := "Destination Workspace Name"
err := reportclient.CopyReports(url, viewnames, destdbname, dbkey)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
copyreports()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
String dbkey = "************";
String destdb = "Destination Workspace Name";
String views = "View1,View2";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void copyreports() throws Exception
{
String uri = rc.getURI(email,dbname);
rc.copyReport(uri,views,destdb,dbkey,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.copyreports();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$views = "View1,View2";
$dbname = "Destination Workspace Name";
$dbkey = "************";
$report_client_request->copyReports($uri, $views, $dbname, $dbkey);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def copyreports(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
rc.copyReports(uri,"View1,View2","Destination Workspace Name","***********")
obj = Sample()
obj.copyreports(obj.rc)
curl -d "ZOHO_ACTION=COPYREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_VIEWTOCOPY=View1,View2&ZOHO_DATABASE_NAME=Destination Workspace name&
ZOHO_COPY_DB_KEY=************"
https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName"
action="COPYREPORTS">
<result>
<message>
Successfully View(s) Copied
</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName",
"action":"COPYREPORTS",
"result":
{
"message": "Successfully View(s) Copied"
}
}
}
源工作空间管理员应生成并提供复制工作空间密钥，这是用于向目标工作空间管理员授权的密钥。使用此 API 复制报告时，将复制报告、所涉及关系以及与源报告相关联的公式列。源工作空间中的视图的父表应以相同名称存在于目标工作空间中。
http 请求
https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName?ZOHO_ACTION=COPYREPORTS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************(Destination user authtoken)&ZOHO_VIEWTOCOPY=EmployeeDetails&ZOHO_DATABASE_NAME=Destination Workspace Name&ZOHO_COPY_DB_KEY=************(Source workspace key)
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | COPYREPORTS | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_VIEWTOCOPY （必需） |
视图名称 | 此参数包含视图名称的列表。如果有多个视图，那么视图名称之间应使用逗号 (,) 分隔。Example:ZOHO_VIEWTOCOPY=View1,View2,View3,… |
| ZOHO_DATABASE_NAME （必需） |
工作空间名称 | 此参数包含必须在其中复制报告（在 ZOHO_VIEWSTOCOPY 参数中指定）的工作空间（目标工作空间）的名称。 |
| ZOHO_COPY_DB_KEY （必需） |
工作空间密钥 | 用于允许用户复制工作空间/报告的密钥。 源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。 https://analyticsapi.zoho.com/api/abcd@zoho.com/SourceEmployeeDB?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_workspace_admin_authtoken>&ZOHO_API_VERSION=1.0. |
COPY REPORTS 中的可能错误代码
复制公式
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void copyformula(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
string formula = "Formula1,Formula2";
string dbname = "Destination Workspace Name";
string dbkey = "***********";
rc.CopyFormula(uri, formula, dbname, dbkey, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.copyformula(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
dbkey = "************"
)
func copyformula() {
url := reportclient.GetUri(email, dbname, tbname)
formulaname := "Formula1,Formula2"
destdbname := "Destination Workspace Name"
err := reportclient.CopyFormula(url, formulaname, destdbname, dbkey)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
copyformula()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
String dbkey = "*************";
String destdb = "Formula1";
String formula = "Destination Workspace Name";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void copyformula() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.copyFormula(uri,formula,destdb,dbkey,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.copyformula();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$formula = "Formula1";
$dbname = "Destination Workspace Name";
$dbkey = "*************";
$report_client_request->copyFormula($uri, $formula, $dbname, $dbkey);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def copyformula(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
rc.copyFormula(uri,"Formula1","Destination Workspace Name","************")
obj = Sample()
obj.copyformula(obj.rc)
curl -d "ZOHO_ACTION=COPYFORMULA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_FORMULATOCOPY=Formula1&ZOHO_DATABASE_NAME=Destination Workspace Name&
ZOHO_COPY_DB_KEY=*************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName"
action="COPYFORMULA">
<result>
<message>
Successfully formula(s) Copied
</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/Workspace name\/TableName",
"action":"COPYFORMULA",
"result":
{
"message": "Successfully Formula(s) Copied"
}
}
}
“复制公式 API”用于将一个或多个公式列从同一个工作空间中的一个表复制到另一个表、跨工作空间复制，甚至从一个用户帐户复制到另一个用户帐户。源工作空间管理员应生成并提供复制工作空间密钥，这是用于向目标工作空间管理员授权的密钥。目标工作空间中的表和列名必须与公式所依赖的源工作空间中的表名和列名相同。可使用此 API 复制自定义公式和汇总公式。
http 请求
https://analyticsapi.zoho.com/api/SourceEmailAddress/SourceWorkspaceName/SourceTableName?ZOHO_ACTION=COPYFORMULA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************(Destination user token)&ZOHO_FORMULATOCOPY=MyFormula1&ZOHO_DATABASE_NAME=Destination Workspace Name&ZOHO_COPY_DB_KEY=**********(Source Workspace key)
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | COPYFORMULA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_FORMULATOCOPY | 公式名称 | 此参数包含要从源工作空间复制到目标工作空间中的另一个表的公式名称。 如果要复制多个公式，公式名称之间应使用逗号 (,) 分隔。 Example: ZOHO_FORMULATOCOPY=MyFormula1,MyFormula2,MyFormulaN |
| ZOHO_DATABASE_NAME | 工作空间名称 | 此参数包含目标表所在的工作空间（目标工作空间）的名称。 所指定公式将复制到具有 API URL 中指定的名称 (SourceEmployeeDetails) 的表中 |
| ZOHO_COPY_DB_KEY | 工作空间密钥 | 用于允许用户复制工作空间/报告的密钥。 源工作空间管理员必须调用以下 URL 以获取复制工作空间密钥。 https://analyticsapi.zoho.com/api/abcd@zoho.com/SourceEmployeeDB?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&authtoken=<source_db_owner_authtoken>&ZOHO_API_VERSION=1.0 . Note: 您需要在以上 URL 中提供相应值，以便为您的设置生成相应的复制工作空间密钥。 |
COPY FORMULA 中的可能错误代码
添加栏
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void addColumn(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
string ColumnName = "Column Name";
string DataType = "PLAIN";
bool HideColumn = false;
bool SkipSystemTableCheck = true;
RepClient.AddColumn(tableURI, ColumnName, DataType, HideColumn,
SkipSystemTableCheck, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.addColumn(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func addcolumn() {
url := reportclient.GetUri(email, dbname, tbname)
columnname := "Column Name"
datatype := "PLAIN"
err := reportclient.AddColumn(url, columnname, datatype)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
addcolumn()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void addcolumn() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.addColumn(uri,"DOB","PLAIN",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.addcolumn();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$column_name = "Column Name";
$data_type = "PLAIN";
$report_client_request->addColumn($uri, $column_name, $data_type);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def AddColumn(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
columnName = "Column Name"
dataType = "PLAIN"
rc.addColumn(uri,columnName,dataType)
obj = Sample()
obj.AddColumn(obj.rc)
curl -d "ZOHO_ACTION=ADDCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_COLUMNNAME=Column Name&ZOHO_DATATYPE=Column Data Type"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDCOLUMN">
<result>
Column created successfully
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"ADDCOLUMN",
"result": {"message":"Column created successfully"}
}
}
“添加列 API”用于向 Zoho Analytics 表添加列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中添加列。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name&ZOHO_DATATYPE=Data Type
Note: 工作空间所有者添加列时，他们只需要指定帐户管理员的登录电子邮件 ID。
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ADDCOLUMN | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要添加至 Zoho Analytics 表的列的名称。Example:ZOHO_COLUMNNAME=Region。 Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。 |
| ZOHO_DATATYPE （必需） |
受支持的数据类型包括： |
要添加至 Zoho Analytics 表的列的数据类型。 |
ADD COLUMN 中的可能错误代码
删除列
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void deleteColumn(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
string ColumnName = "Column Name";
bool DeleteDependentView = false;
bool SkipSystemTableCheck = true;
RepClient.DeleteColumn(tableURI, ColumnName, DeleteDependentView,
SkipSystemTableCheck, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.deleteColumn(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func deletecolumn() {
url := reportclient.GetUri(email, dbname, tbname)
columnname := "Column Name"
err := reportclient.DeleteColumn(url, columnname)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
deletecolumn()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void deletecolumn() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.deleteColumn(uri,"Column Name",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.deletecolumn();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$column_name = "Column Name";
$report_client_request->deleteColumn($uri, $column_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def DeleteColumn(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
columnName = "Column Name"
rc.deleteColumn(uri,columnName)
obj = Sample()
obj.DeleteColumn(obj.rc)
curl -d "ZOHO_ACTION=DELETECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_COLUMNNAME=Column Name"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="DELETECOLUMN">
<result>
Column deleted successfully
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"DELETECOLUMN",
"result": {"message":"Column deleted successfully"}
}
}
“删除列 API”用于在 Zoho Analytics 表中删除列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中删除列。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=DELETECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=COlumn Name
Note: 工作空间管理员删除列时，他们只需要指定帐户管理员的登录电子邮件 ID。
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DELETECOLUMN | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于 CTION 的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要在 Zoho Analytics 表中删除的列的名称。Example:ZOHO_COLUMNNAME=Region |
DELETE COLUMN 中的可能错误代码
重命名列
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void renameColumn(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
string OldColumnName = "Old Column Name";
string NewColumnName = "New Column Name";
bool SkipSystemTableCheck = true;
RepClient.RenameColumn(tableURI, OldColumnName, NewColumnName,
SkipSystemTableCheck, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.renameColumn(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func renamecolumn() {
url := reportclient.GetUri(email, dbname, tbname)
oldcolumnname := "Old Column Name"
newcolumnname := "New Column Name"
err := reportclient.RenameColumn(url, oldcolumnname, newcolumnname)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
renamecolumn()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void renamecolumn() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.renameColumn(uri,"Old Column Name","New Column Name",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.renamecolumn();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$old_column_name = "Old Column Name";
$new_column_name = "New Column Name";
$report_client_request->renameColumn($uri, $old_column_name,
$new_column_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def RenameColumn(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
oldColumnName = "Old Column Name"
newColumnName = "New Column Name"
rc.renameColumn(uri,oldColumnName,newColumnName)
obj = Sample()
obj.RenameColumn(obj.rc)
curl -d "ZOHO_ACTION=RENAMECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&OLDCOLUMNNAME=Old Column Name&NEWCOLUMNNAME=New Column Name"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="RENAMECOLUMN">
<result>
Column renamed successfully
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"RENAMECOLUMN",
"result":
{
"message":"Column renamed successfully"
}
}
}
“重命名列 API”用于在 Zoho Analytics 表中重命名列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中重命名列。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=RENAMECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&OLDCOLUMNNAME=Old Column Name&NEWCOLUMNNAME=New Column Name
Note: 工作空间管理员重命名列时，他们只需要指定帐户管理员的登录电子邮件 ID。
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | RENAMECOLUMN | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| OLDCOLUMNNAME （必需） |
<oldcolumnname> |
要在 Zoho Analytics 表中重命名的列的名称。 Example: OLDCOLUMNNAME=Region |
| NEWCOLUMNNAME （必需） |
<newcolumnname> |
要对该列指定的新名称。Example:NEWCOLUMNNAME=SalesRegion |
RENAME COLUMN 中的可能错误代码
隐藏列
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void hidecolumn(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
string[] columnNames = new string[3];
columnNames[0] = "COlumn1";
columnNames[1] = "COlumn2";
columnNames[2] = "Column3";
var result = rc.HideColumn(uri,columnNames,null);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.hidecolumn(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func hidecolumn(){
url := reportclient.GetUri(email, dbname, tbname)
columnnames := []string{"Column1" , "Column2" , "Column3"}
params := map[string]string{}
result , err := reportclient.HideColumn(url, columnnames, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
hidecolumn()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void hidecolumn() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
List columnNames = new ArrayList();
columnNames.add("Column1");
columnNames.add("Column2");
Map result = rc.hideColumn(uri, columnNames, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.hidecolumn();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$columnNames = array("Column1","Column2");
$response = $request->hideColumn($uri ,$columnNames);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def hidecolumn(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
params = []
params.append("Column1")
params.append("Column2")
params.append("Column3")
result = rc.hideColumn(uri,params)
print result
obj = Sample()
obj.hidecolumn(obj.rc)
curl -d "ZOHO_ACTION=HIDECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="HIDECOLUMN">
<result>
<column columnName="Column1" status="Success" message="column hidden successfully"> </column>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "HIDECOLUMN",
"result": [
{
"columnName": "Column1",
"status": "Success",
"message": "column hidden successfully"
}
]
}
}
“隐藏列 API”用于在 Zoho Analytics 表中隐藏列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中隐藏列。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=HIDECOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2
Note: 工作空间管理员隐藏列时，他们只需要指定帐户管理员的登录电子邮件 ID。
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | HIDECOLUMN | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要在 Zoho Analytics 表中隐藏的列的名称。 Example: ZOHO_COLUMNNAME=Region。 注：允许使用多个参数。 |
HIDE COLUMN 中的可能错误代码
显示列
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void showcolumn(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
string[] columnNames = new string[3];
columnNames[0] = "Column1";
columnNames[1] = "Column2";
columnNames[2] = "Column3";
var result = rc.ShowColumn(uri,columnNames,null);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.showcolumn(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func showcolumn(){
url := reportclient.GetUri(email, dbname, tbname)
columnnames := []string{"Column1" , "Column2" , "Column3"}
params := map[string]string{}
result , err := reportclient.ShowColumn(url, columnnames, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
showcolumn()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void showcolumn() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
List columnNames = new ArrayList();
columnNames.add("Column1");
columnNames.add("Column2");
Map result = rc.showColumn(uri, columnNames, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.showcolumn();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$columnNames = array("Column1","Column2");
$response = $request->showColumn($uri ,$columnNames);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def showcolumn(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
params = []
params.append("Column1")
params.append("Column2")
params.append("Column3")
result = rc.showColumn(uri,params)
print result
obj = Sample()
obj.showcolumn(obj.rc)
curl -d "ZOHO_ACTION=SHOWCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_COLUMNNAME=Column1&ZOHO_COLUMNNAME=Column2"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="SHOWCOLUMN">
<result>
<column columnName="Column1" status="Success" message="column shown successfully"> </column>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress/WorkspaceName/TableName",
"action": "SHOWCOLUMN",
"result": [
{
"columnName": "Column1",
"status": "Success",
"message": "column shown successfully"
}
]
}
}
“显示列 API”用于在 Zoho Analytics 表中显示列。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中显示列。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=SHOWCOLUMN&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=COlumn1&ZOHO_COLUMNNAME=Column2
Note: 工作空间管理员显示列时，他们只需要指定帐户管理员的登录电子邮件 ID。
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | SHOWCOLUMN | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要在 Zoho Analytics 表中显示的列的名称。 Example: ZOHO_COLUMNNAME=Region。 注：允许使用多个参数。 |
SHOW COLUMN 中的可能错误代码
添加查找
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void addlookup(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
string columnname = "Column Name";
string reftable = "Ref Table Name";
string refcolumn = "Ref Column Name";
string onerror = "ABORT";
rc.AddLookup(uri, columnname, reftable, refcolumn, onerror, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.addlookup(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func addlookup() {
url := reportclient.GetUri(email, dbname, tbname)
columnname := "COlumn Name Name"
refertable := "Ref Table Name"
refercolumn := "Ref Column Name"
onerror := "ABORT"
err := reportclient.AddLookup(url, columnname, refertable, refercolumn
, onerror)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
addlookup()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void addlookup() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.addLookup(uri,"Column Name","Ref Table Name","Ref Column Name","ABORT",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.addlookup();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$column_name = "Column Name";
$referred_table = "Ref Table Name";
$referred_column = "Ref Column Name";
$on_error = "ABORT";
$report_client_request->addLookup($uri, $column_name, $referred_table,
$referred_column, $on_error);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def addlookup(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
result = rc.addLookup(uri,"Column Name","Ref Table Name","Ref Column Name","ABORT")
obj = Sample()
obj.addlookup(obj.rc)
curl -d "ZOHO_ACTION=ADDLOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_COLUMNNAME="Column Name"&ZOHO_REFERREDTABLE="Ref Table Name"&
ZOHO_REFERREDCOLUMN="Ref Column Name"&ZOHO_IFERRORONCONVERSION="ABORT""
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="ADDLOOKUP">
<result>SUCCESS</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"ADDLOOKUP",
"result":"SUCCESS"
}
}
“添加查找 API”用于在所指定子表中添加查找。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=ADDLOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name&ZOHO_REFERREDTABLE=Ref Table Name&ZOHO_REFERREDCOLUMN=Ref Column Name&ZOHO_IFERRORONCONVERSION=ABORT
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ADDLOOKUP | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要添加至 Zoho Analytics 表的列的名称。Example:ZOHO_COLUMNNAME=Region。 Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。 |
| ZOHO_REFERREDTABLE （必需） |
表名 | 被引用表的名称。 |
| ZOHO_REFERREDCOLUMN （必需） |
列名 | 被引用表中的列的名称。 |
| ZOHO_IFERRORONCONVERSION （必需） |
ABORT/EMPTY | 如果转换时发生错误。 |
ADD LOOKUP 中的可能错误代码
移除查找
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void removelookup(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
string columnname = "Column Name";
rc.RemoveLookup(uri, columnname, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.removelookup(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func removelookup() {
url := reportclient.GetUri(email, dbname, tbname)
columnname := "Column Name"
err := reportclient.RemoveLookup(url, columnname)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
removelookup()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void removelookup() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
rc.removeLookup(uri,"Column Name",config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.removelookup();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$column_name = "Column Name";
$report_client_request->removeLookup($uri, $column_name);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def removelookup(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
result = rc.removeLookup(uri,"Column Name")
obj = Sample()
obj.removelookup(obj.rc)
curl -d "ZOHO_ACTION=REMOVELOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=JSON&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_COLUMNNAME="Column Name""
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="REMOVELOOKUP">
<result>SUCCESS</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"REMOVELOOKUP",
"result":"SUCCESS"
}
}
“移除查找 API”用于移除针对给定表中的指定列的查找。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=REMOVELOOKUP&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_COLUMNNAME=Column Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | REMOVELOOKUP | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_COLUMNNAME （必须） |
<columnname> |
要添加至 Zoho Analytics 表的列的名称。Example:ZOHO_COLUMNNAME=Region。 Note: 如果列名包含空格或任意特殊字符，那么应使用 URL 编写列名。 |
REMOVE LOOKUP 中的可能错误代码
“建模 API”中的错误代码
样本错误 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName" action="COPYDATABASE">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the Workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "COPYDATABASE",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the Workspace exists"
}
}
}
本节列示“建模 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 7101 | 同名工作空间已存在。 | 请提供另一名称。 |
| 7103 | API URL 中提到的工作空间名称不存在。 | 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。 |
| 7105 | 工作空间中指定的视图名称不存在。 | 请提供有效视图名称。 |
| 7107 | 该列在所指定 Zoho Analytics 表中不存在。 | 请在 ZOHO_COLUMNNAME 参数中提供要删除的列的正确名称。 |
| 7111 | 带有该名称的表在此工作空间中已存在。 | 请提供另一名称。 |
| 7128 | 带有相同名称的列在 Zoho Analytics 表中已存在。 | 请对 ZOHO_COLUMNNAME 参数提供不同名称。 |
| 7138 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 7144 | 所提及文件夹在此工作空间中不存在。 | 请检查所提及文件夹是否可用。 |
| 7159 | 要删除的列用于报告、公式列、查询表等等。 | 无法删除带有关联视图的列。调用此“删除列 API”之前，请删除与此列相关的关联视图和公式列。 |
| 7161 | 此 API 中指定的 Zoho Analytics 表是系统表（针对服务集成创建的表）。 | 不允许在系统表中添加列。使用此 API 时只能在非系统表中添加列。 |
| 7165 | 所指定工作空间是无法删除的系统工作空间（专为其他 Zoho 服务集成创建的工作空间）。 | 无法删除系统工作空间。 |
| 8023 | 您无权执行此操作。 | 请联系我们的支持团队。 |
| 8024 | 不允许执行“复制工作空间”操作。 | 请检查 URL 中提供的工作空间密钥。 |
| 8025 | 无效自定义域。 | 请提供有效域名。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
| 8534 | 无效的 JSON 格式。 | 请提供有效 JSON 数据。 |
| 15000 | 目标工作空间中缺少复制所指定报告时所需的表。 | 检查目标工作空间并创建缺少的表。 |
| 15001 | 目标工作空间中缺少复制所指定报告时所需的列。 | 检查目标工作空间并在复制报告之前创建该列。 |
| 15002 | 目标工作空间中缺少复制所指定报告时所需的公式列。 | 检查目标工作空间并在复制报告之前创建公式列。 |
| 15005 | 所指定报告名称已存在于目标工作空间中。 | 检查目标工作空间中是否存在同名报告。尝试重命名源报告或目标工作空间中的报告，然后再次调用该 API。 |
| 15007 | 权限不足，无法复制报告。 | 检查复制工作空间密钥是否有效。 |
| 15009 | 所指定公式列名已存在于目标工作空间中。 | 检查公式列是否已被复制，或者尝试重命名源表或目标工作空间中的公式列，然后再次调用该 API。 |
| 15010 | API 请求中指定的公式列名称不在源表中。 | 检查 ZOHO_FORMULATOCOPY 参数中指定的公式列名称是否正确。 |
| 15012 | API 请求中指定的报告不在源工作空间中。 | 检查 ZOHO_VIEWTOCOPY 参数中指定的报告是否正确并可用。 |
如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
元数据 API
本节列示所有元数据 API。元数据 API 可用于获取有关报告 Zoho Analytics 中创建的工作空间、表、报告和统计图表的信息。
工作空间元数据
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getDatabaseMetaData(IReportClient RepClient)
{
string dbURI = RepClient.GetURI(EMAIL, DBNAME);
string metaData = "ZOHO_CATALOG_INFO";
string format = "XML"
string result = RepClient.GetDatabaseMetaData(dbURI, metaData, format, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getDatabaseMetaData(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func databasemetadata() {
url := reportclient.GetUserUri(email)
metadata := "ZOHO_CATALOG_LIST"
data , err := reportclient.GetDatabaseMetadata(url, metadata)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(data)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
databasemetadata()
}
import java.util.HashMap;
import java.util.Map;
import org.w3c.dom.Document;
import com.adventnet.zoho.client.report.*;
public class Sample
{
String authtoken = "************";
String email = "Email Address";
Map<String, String> config = new HashMap<String, String>();
private ReportClient rc = new ReportClient(authtoken);
public void metadata() throws Exception
{
String uri = rc.getURI(email);
Document result = rc.getDatabaseMetaData(uri,"ZOHO_CATALOG_LIST",config);
}
public static void main(String[] args)
throws Exception
{
Sample obj = new Sample();
obj.metadata();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$metadata = "ZOHO_CATALOG_LIST";
$report_client_response = $report_client_request->getDatabaseMetadata($uri, $metadata);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getdatabasemetadata(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
result = rc.getDatabaseMetadata(uri,"ZOHO_CATALOG_LIST")
print result
obj = Sample()
obj.getdatabasemetadata(obj.rc)
curl -d "ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=
XML&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_METADATA=ZOHO_CATALOG_LIST"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response URI="/api/EmailAddress" ACTION="ZOHO_CATALOG_LIST">
<ZCATALOGS>
<ZCATALOG IS_DEFAULT="1" TABLE_CAT="SalesDB"></ZCATALOG>
<ZCATALOG IS_DEFAULT="0" TABLE_CAT="Super Store Sales"></ZCATALOG>
<ZCATALOG IS_DEFAULT="0" TABLE_CAT="Project Manager"></ZCATALOG>
</ZCATALOGS>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ZOHO_CATALOG_LIST",
"result":
[
{
"isDefault": true,
"tableCat": "SalesDB"
},
{
"isDefault": false,
"tableCat": "Super Store Sales"
},
{
"isDefault": false,
"tableCat": "Project Manager"
}
]
}
}
目录信息的样本响应
XML 格式：
<response URI="/api/EmailAddress/WorkspaceName" ACTION="ZOHO_CATALOG_INFO">
<ZCATALOG TABLE_CAT="SalesDB">
<ZVIEW REMARKS="\N" TABLE_NAME="SalesTable" TABLE_TYPE="TABLE">
<ZCOLUMNS>
<ZCOLUMN COLUMN_NAME="REGION" PKCOLUMN_NAME="\N" NULLABLE="true"
COLUMN_SIZE="100"PKTABLE_NAME="\N" DATA_TYPE="12" REMARKS="\N"
TYPE_NAME="Plain Text"
DECIMAL_DIGITS="-1" ORDINAL_POSITION="1"></ZCOLUMN>
<ZCOLUMN COLUMN_NAME="Order Date" PKCOLUMN_NAME="\N" NULLABLE="true"
COLUMN_SIZE="19"
PKTABLE_NAME="\N" DATA_TYPE="93" REMARKS="\N" TYPE_NAME="Date"
DECIMAL_DIGITS="-1" ORDINAL_POSITION="6"></ZCOLUMN>
</ZCOLUMNS>
</ZVIEW>
<ZVIEW REMARKS="\N" TABLE_NAME="Region" TABLE_TYPE="REPORT"></ZVIEW>
<ZVIEW REMARKS="\N" TABLE_NAME="SalesTabular" TABLE_TYPE="REPORT">
<ZVIEW REMARKS="\N" TABLE_NAME="SalesQuery" TABLE_TYPE="VIEW">
<ZCOLUMNS>
<ZCOLUMN COLUMN_NAME="Market Type" PKCOLUMN_NAME="\N"NULLABLE="false"
COLUMN_SIZE="100"
PKTABLE_NAME="\N" DATA_TYPE="12" REMARKS="\N" TYPE_NAME="Plain Text"
DECIMAL_DIGITS="-1" ORDINAL_POSITION="1"></ZCOLUMN>
<ZCOLUMN COLUMN_NAME="Order Date" PKCOLUMN_NAME="\N"NULLABLE="false"
COLUMN_SIZE="19"
PKTABLE_NAME="\N" DATA_TYPE="93" REMARKS="\N" TYPE_NAME="Date"
DECIMAL_DIGITS="-1" ORDINAL_POSITION="2"></ZCOLUMN>
</ZCOLUMNS>
</ZVIEW>
<ZVIEW REMARKS="\N" TABLE_NAME="SalesPivot" TABLE_TYPE="REPORT"></ZVIEW>
<ZVIEW REMARKS="\N" TABLE_NAME="SalesSummary" TABLE_TYPE="REPORT"></ZVIEW>
</response>
JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "ZOHO_CATALOG_INFO",
"result":
{
"views":
[
{
"remarks": null,
"tableName": "SalesTable",
"tableType": "TABLE",
"columns":
[
{
"columnName": "REGION",
"pkcolumnName": null,
"nullable": true,
"columnSize": 100,
"pktableName": null,
"dataType": "12",
"remarks": null,
"typeName": "Plain Text",
"decimalDigits": -1,
"ordinalPosition": 1
},
{
"columnName": "Order Date",
"pkcolumnName": null,
"nullable": true,
"columnSize": 19,
"pktableName": null,
"dataType": "93",
"remarks": null,
"typeName": "Date",
"decimalDigits": -1,
"ordinalPosition": 6
}
]
},
{
"remarks": "Region wise chart for the year 2009",
"tableName": "Region",
"tableType": "REPORT",
"columns":
[
]
},
{
"remarks": null,
"tableName": "SalesTabular",
"tableType": "REPORT",
"columns":
[
]
},
{
"remarks": null,
"tableName": "SalesQuery",
"tableType": "VIEW",
"columns":
[
{
"columnName": "Market Type",
"pkcolumnName": null,
"nullable": false,
"columnSize": 100,
"pktableName": null,
"dataType": "12",
"remarks": null,
"typeName": "Plain Text",
"decimalDigits": -1,
"ordinalPosition": 1
},
{
"columnName": "Order Date",
"pkcolumnName": null,
"nullable": false,
"columnSize": 19,
"pktableName": null,
"dataType": "93",
"remarks": null,
"typeName": "Date",
"decimalDigits": -1,
"ordinalPosition": 2
}
]
},
{
"remarks": null,
"tableName": "SalesPivot",
"tableType": "REPORT",
"columns":
[
]
},
{
"remarks": null,
"tableName": "SalesSummary",
"tableType": "REPORT",
"columns":
[
]
}
],
"tableCat": "SalesDB"
}
}
}
数据类型信息的样本响应
XML 格式：
<response URI="/api/EmailAddress" ACTION="ZOHO_DATATYPES">
<ZDATATYPES>
<ZDATATYPE LITERAL_PREFIX="'" MAXSIZE="19" MAXIMUM_SCALE="\N"
NULLABLE="1"
TYPE_NAME="Positive Number" DATA_TYPE="-5" MINIMUM_SCALE="\N"
SQL_DATA_TYPE="-5"
FIXED_PREC_SCALE="false" LOCAL_TYPE_NAME="\N" AUTO_INCREMENT="false"
SQL_DATETIME_SUB="0" PRECISION="-1" UNSIGNED_ATTRIBUTE="true" ID="5">
</ZDATATYPE>
<ZDATATYPE LITERAL_PREFIX="'" MAXSIZE="1" MAXIMUM_SCALE="\N"
NULLABLE="1"
TYPE_NAME="Yes/No Decision" DATA_TYPE="-7" MINIMUM_SCALE="\N"
SQL_DATA_TYPE="-7"
FIXED_PREC_SCALE="false" LOCAL_TYPE_NAME="\N" AUTO_INCREMENT="false"
SQL_DATETIME_SUB="0" PRECISION="-1" UNSIGNED_ATTRIBUTE="false" ID="10">
</ZDATATYPE>
</ZDATATYPES>
</response>
JSON 格式
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ZOHO_DATATYPES",
"result":
[
{
"literalPrefix": "\'",
"maxsize": 19,
"maximumScale": null,
"nullable": true,
"dataType": -5,
"minimumScale": null,
"sqlDataType": -5,
"fixedPrecScale": false,
"localTypeName": null,
"autoIncrement": false,
"searchable": false,
"literalSuffix": "\'",
"caseSensitive": true,
"numPrecRadix": "10",
"typeName": "Positive Number",
"createParams": "500",
"sqlDatetimeSub": "0",
"precision": -1,
"unsignedAttribute": true,
"id": "5"
},
{
"literalPrefix": "\'",
"maxsize": 1,
"maximumScale": null,
"nullable": true,
"dataType": -7,
"minimumScale": null,
"sqlDataType": -7,
"fixedPrecScale": false,
"localTypeName": null,
"autoIncrement": false,
"searchable": false,
"literalSuffix": "\'",
"caseSensitive": true,
"numPrecRadix": "10",
"typeName": "Yes\/No Decision",
"createParams": "500",
"sqlDatetimeSub": "0",
"precision": -1,
"unsignedAttribute": false,
"id": "10"
}
]
}
}
表类型的样本响应
XML 格式：
<response URI="/api/EmailAddress" ACTION="ZOHO_TABLETYPES">
<ZVIEWTYPES >
<ZVIEWTYPE TYPE="TABLE"></ZVIEWTYPE>
<ZVIEWTYPE TYPE="VIEW"></ZVIEWTYPE>
<ZVIEWTYPE TYPE="REPORT"></ZVIEWTYPE>
</ZVIEWTYPES>
</response>
JSON 格式
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ZOHO_TABLETYPES",
"result":
[
"TABLE",
"VIEW",
"REPORT"
]
}
}
通过使用“工作空间元数据 API”，您可获取以下元信息。
- 您的帐户中的报告工作空间的列表
- 您的报告工作空间中的视图列表及视图信息
- Zoho Analytics 中的不同可用视图
- Zoho Analytics 中的可用数据类型
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_LIST
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DATABASEMETADATA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_METADATA | 受支持的值为： |
指定要获取的信息。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
1. 获取工作空间（目录）列表
列示所指定用户的 Zoho Analytics 工作空间
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_LIST
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DATABASEMETADATA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_METADATA | ZOHO_CATALOG_LIST | 列示所指定用户的 Zoho Analytics 工作空间 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
2. 获取工作空间中的表和报告（目录信息）
获取有关 Zoho Analytics 内给定报告工作空间中的表和报告（视图）的信息。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_CATALOG_INFO
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DATABASEMETADATA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_METADATA | ZOHO_CATALOG_INFO | 获取有关 Zoho Analytics 内给定报告工作空间中的表和报告（视图）的信息。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
3. 获取数据类型信息
下表列示常规数据类型编号及其对应类型名称。
| 数据类型编号 | 类型名称 |
|---|---|
| 12 | 纯文本 / 多行文本 / 电子邮件 / URL |
| -7 | 是 / 无决定 |
| 8 | 百分比 / 货币 / 小数 |
| -5 | 数字 / 自动数字 / 正数 |
| 93 | 日期 |
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_DATATYPES
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DATABASEMETADATA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_METADATA | ZOHO_DATATYPES | 获取 Zoho Analytics 支持的数据类型列表 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
4. 获取表类型
下表列示常规表类型。
| 实际视图 | 表类型值 |
|---|---|
| 表 | 表 |
| 查询表 | 视图 |
| 图表 / 透视图 / 表格视图 / 摘要视图 / 统计图表 | REPORT |
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DATABASEMETADATA&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_METADATA=ZOHO_TABLETYPES
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DATABASEMETADATA | 此参数指定 API 请求要执行的操作。 |
| ZOHO_METADATA | ZOHO_TABLETYPES | Zoho Analytics 中的各种可用视图类型 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
响应属性
在本节中，我们描述了在 DATABASEMETADATA API 中使用的属性的详细说明。
| 属性 | 描述 |
|---|---|
| IS_DEFAULT/isDefault | 指示 Zoho Analytics 工作空间是否设置为默认值。可用于为使用 JDBC 驱动程序加载 Zoho Analytics 工作空间的第三方工具设置默认工作空间。 |
| TABLE_CAT/tableCat | Zoho Analytics 工作空间名称（例如：SalesDB） |
| COLUMN_NAME/columnName | 表类型视图中的列的名称（例如：Region） |
| LITERAL_PREFIX | 发现文字值时使用的前缀字符（例如：'45’） |
| NULLABLE | 如果列可包含空值，那么将为 true，否则为 false。 |
| MAXSIZE | 列的最大大小（例如：20） |
| TYPE_NAME | 数据类型的 Zoho Analytics 名称（例如：正数） |
Note:XML 响应中的 \N 是指空值
使用 JDBC 驱动程序获取元数据
如果要使用 Java 应用程序，那么 Zoho Analytics 会提供 JDBC 驱动程序，它可用于获取所有 Zoho Analytics 元数据信息。有关详细信息，请参阅
WORKSPACE METADATA 中的可能错误代码
获取工作空间名称
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBID = 999999999999999;
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getdbname(IReportClient rc)
{
string uri = rc.GetURI(EMAIL);
string result = rc.GetDatabaseName(uri, DBID, null);
Console.WriteLine(result);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getdbname(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
dbid = "999999999999999"
)
func getdatabasename() {
url := reportclient.GetUserUri(email)
databasename , err := reportclient.GetDatabaseName(url, dbid)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(databasename)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getdatabasename()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
long dbid = 999999999999999;
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void getdbname() throws Exception
{
String uri = rc.getURI(email);
String result = rc.getDatabaseName(uri,dbid);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getdbname();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$db_id = 999999999999999;
$database_name = $report_client_request->getDatabaseName($uri, $db_id);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DBID="999999999999999"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getdatabasename(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
result = rc.getDatabaseName(uri,self.DBID)
print result
obj = Sample()
obj.getdatabasename(obj.rc)
curl -d "ZOHO_ACTION=GETDATABASENAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=
XML&ZOHO_API_VERSION=1.0&authtoken=************&
DBID=999999999999999"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="GETDATABASENAME">
<dbname>Employee</dbname>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "GETDATABASENAME",
"result":
{
"dbname": "Employee"
}
}
}
在给定工作空间 ID 作为输入的情况下，此 API 返回 Zoho Analytics 中的工作空间的名称。工作空间 ID 是与 Zoho Analytics 中创建的每个报告工作空间相关联的唯一标识。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETDATABASENAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&DBID=999999999999999
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETDATABASENAME | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| DBID （必需） |
长数字，例如，9999999999999 | Zoho Analytics 在线报告工作空间的 DBID，可从工作空间 URL 获取 |
GET WORKSPACE NAME 中的可能错误代码
工作空间是否存在
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void isdbexist(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL);
bool result = rc.IsDbExist(uri, "Workspace Name", null);
Console.WriteLine(result);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.isdbexist(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func isdbexist(){
url := reportclient.GetUserUri(email)
databasename := "Workspace Name"
params := map[string]string{}
result , err := reportclient.IsDbExist(url, databasename, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
isdbexist()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void isdbexist() throws Exception
{
String uri = rc.getURI(email);
boolean result = rc.isDbExist(uri, "Workspace Name", null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.isdbexist();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getUserURI($EMAIL_ID);
$dbname = "<db-name>";
$result = $request->isDbExist($uri, $dbname);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def isdbexist(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
dbname = "Workspace Name"
result = rc.isDbExist(uri,dbname)
print result
obj = Sample()
obj.isdbexist(obj.rc)
curl -d "ZOHO_ACTION=ISDBEXIST&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DB_NAME=Workspace Name"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress" action="ISDBEXIST">
<result>
<isdbexist>true</isdbexist>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress",
"action": "ISDBEXIST",
"result": {
"isdbexist": "true"
}
}
}
“工作空间是否存在 API”用于检查工作空间在 Zoho Analytics 帐户中是否存在。只有帐户管理员和工作空间管理员才能使用此 API 在 Zoho Analytics 表中检查工作空间。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ISDBEXIST&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_DB_NAME=Workspace Name
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ISDBEXIST | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_DB_NAME （必需） |
<Workspacename> |
此参数包含工作空间的名称 |
IS WORKSPACE EXIST 中的可能错误代码
获取工作空间密钥
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void
(IReportClient RepClient)
{
string dbURI = RepClient.GetURI(EMAIL, DBNAME);
string key = RepClient.GetCopyDBKey(dbURI, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.copyDatabaseKey(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func getcopydbkey() {
url := reportclient.GetDbUri(email, dbname)
dbkey , err := reportclient.GetCopyDbKey(url)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(dbkey)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getcopydbkey()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void copydatabasekey() throws Exception
{
String uri = rc.getURI(email,dbname);
String key = rc.getCopyDBKey(uri, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.copydatabasekey();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getDbURI($EMAIL_ID, $DB_NAME);
$database_key = $request->getCopyDbKey($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def CopyDatabaseKey(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
result = rc.getCopyDBKey(self.uri)
obj = Sample()
obj.CopyDatabaseKey(obj.rc)
curl -d "ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="GETCOPYDBKEY">
<result>
<copydbkey>************</copydbkey>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress/WorkspaceName",
"action": "GETCOPYDBKEY",
"result": {
"copydbkey": "************"
}
}
}
“获取工作空间 API”用于获取特定工作空间密钥。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETCOPYDBKEY&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETCOPYDBKEY | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
COPY WORKSPACE KEY 中的可能错误代码
获取视图名称
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
OBJID = ************;
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getviewname(IReportClient rc)
{
string uri = rc.GetURI(EMAIL);
string result = rc.GetViewName(uri, OBJID, null);
Console.WriteLine(result);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getviewname(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
objid = "************"
)
func getviewname() {
url := reportclient.GetUserUri(email)
viewname , err := reportclient.GetViewname(url, objid)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(viewname)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getviewname()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
long objid = ************;
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void getviewname() throws Exception
{
String uri = rc.getURI(email);
String result = rc.getViewName(uri,objid,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getviewname();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$objid = ************;
$view_name = $report_client_request->getViewName($uri, $objid);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
ODBID="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getviewname(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
result = rc.getViewName(uri,self.OBJID)
print result
obj = Sample()
obj.getviewname(obj.rc)
curl -d "ZOHO_ACTION=GETVIEWNAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&OBJID=************"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="GETVIEWNAME">
<viewname>Employee Details</viewname>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "GETVIEWNAME",
"result":
{
"viewname": "Employee Details"
}
}
}
在给定视图 ID 作为输入的情况下，此 API 返回 Zoho Analytics 中的视图的名称。视图 ID 是与 Zoho Analytics 中创建的每个视图（表、报告和统计图表）相关联的唯一标识。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETVIEWNAME&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&OBJID=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETVIEWNAME | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| OBJID （必需） |
长数字，例如，9999999999999 | 可从对应视图 URL 获取的视图 ID。 |
GET VIEW NAME 中的可能错误代码
获取信息
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getinfo(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME, TBNAME);
var result = rc.GetInfo(uri, null);
foreach (KeyValuePair<string, long> kvp in result)
{
Console.WriteLine(kvp.Key + " " + kvp.Value);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getinfo(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func getinfo() {
url := reportclient.GetUri(email, dbname, tbname)
info , err := reportclient.GetInfo(url)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(info)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getinfo()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void getinfo() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
Map result = rc.getInfo(uri,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getinfo();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$report_info = $report_client_request->getInfo($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getinfo(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
result = rc.getInfo(uri)
print result
obj = Sample()
obj.getinfo(obj.rc)
curl -d "ZOHO_ACTION=GETINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETINFO">
<objid>99999999999999</objid>
<dbid>88888888888888</dbid>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
"action": "GETINFO",
"result":
{
"objid": "99999999999999",
"dbid": "88888888888888"
}
}
}
此 API 返回作为 API 输入提供的对应工作空间和视图名称的工作空间 ID (DBID) 和视图 ID (OBJID)。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETINFO | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
GET INFO 中的可能错误代码
“元数据 API”中的错误代码
样本错误 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName" action="DATABASEMETADATA">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the Workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "DATABASEMETADATA",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the Workspace exists"
}
}
}
本节列示“元数据 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 7102 | API 请求 URL 中指定的工作空间名称为空。 | 检查 API 请求 URL，并提供有效的工作空间名称。 |
| 7103 | API URL 中提到的工作空间名称不存在。 | 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。 |
| 7104 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 7106 | 视图 ID 在工作空间中不存在。 | 请提供有效 OBJID。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
共享与协作 API
本节提供用于共享与协作的 API。您可通过 API 以在进行细粒度控制的情况下将 Zoho Analytics 中创建的视图（报告和统计图表）共享给用户。还可通过 API 管理共享及移除共享。
共享视图
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void shareview(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string emails = "user1@zoho.com";
string views = "Employee";
Dictionary<string, string> dic = new Dictionary<string, string>();
dic.Add("ZOHO_READ", "true");
rc.ShareView(uri, emails, views, dic);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.shareview(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func shareview() {
url := reportclient.GetDbUri(email, dbname)
emailids := "user1@zoho.com"
views := "TableName1,TableName2"
params := map[string]string{}
params["ZOHO_READ"] = "true"
err := reportclient.ShareView(url, emailids, views, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
shareview()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
String emails = "abc@zoho.com";
String views = "TableName1.TableName2";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void shareview() throws Exception
{
String uri = rc.getURI(email,dbname);
config.put("ZOHO_READ", true);
rc.shareView(uri,views,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.shareview();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$emails = "user1@zoho.com";
$views = "viewname1,viewname2";
$criteria = NULL;
$premissions = array('ZOHO_READ' => "true");
$report_client_request->shareView($uri, $emails, $views, $criteria, $permissions);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def shareview(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
permissions = {"ZOHO_READ":"true"}
rc.shareView(uri,"user1@zoho.com","viewname1",None,permissions)
obj = Sample()
obj.shareview(obj.rc)
curl -d "ZOHO_ACTION=SHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_VIEWS=viewname1,viewname2&ZOHO_EMAILS=abc@zoho.com&ZOHO_READ=true"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="SHARE">
<result>success</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName",
"action": "SHARE",
"result": "success"
}
}
通过 Zoho Analytics 的“共享 API”，您可将 Zoho Analytics 中创建的视图（表/报告/统计图表）共享给用户。“共享 API”还允许您撤销所授予的共享权限。使用 API 之前，建议阅读“共享与协作”文档以更好地了解该 API。
Note: 可通过再次调用“Share”来更新共享权限（覆盖现有共享权限）。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=SHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_VIEWS=NewChart&ZOHO_EMAILS=abc@zoho.com&ZOHO_READ=true
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | SHARE | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
Note:建议在 API URL 中使用 Zoho Analytics 登录电子邮件地址来代替 Zoho 用户名。
特定于操作的参数
| 参数 | 可能的值 | 描述 | 评论 |
|---|---|---|---|
| ZOHO_VIEWS | Table1,View1,View2,My View | 要共享的视图的列表。可通过在视图间用逗号分隔的方式共享多个视图。Note:ZOHO_VIEWS 是以 URL 编码格式编写的。下面给出没有编码的值：ZOHO_VIEWS=Table1,View1,View2,My View |
必备参数 |
| ZOHO_EMAILS | user1@finepick.com, user2@finepick.com | 需要与其共享视图的用户电子邮件地址（以逗号分隔值的形式）。Note:ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值： ZOHO_EMAILS=user1@finepick.com,user2@finepick.com |
必备参数 |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于将视图共享给白标客户。 | 可选 |
POST 参数，用于细粒度权限（下面需要至少一个参数）
| 参数 | 允许的值 | 默认值 | 描述 |
|---|---|---|---|
| ZOHO_READ | true 或 false | false | 对视图的读访问权 |
| ZOHO_EXPORT | true 或 false | false | 对视图的导出权限 |
| ZOHO_VUD | true 或 false | false | 查看图表/透视图/摘要视图中的底层数据的权限 |
| ZOHO_DRILLDOWN | true 或 false | false | 在图表中向下展开的权限 |
| ZOHO_ADDROW | true 或 false | false | 在表中添加行的权限 |
| ZOHO_UPDATEROW | true 或 false | false | 在表中更新行的权限 |
| ZOHO_DELETEROW | true 或 false | false | 在表中删除行的权限 |
| ZOHO_DELETEALLROWS | true 或 false | false | 在表中删除所有行的权限 |
| ZOHO_IMPORT_APPEND | true 或 false | false | 使用 APPEND 选项在表中导入数据的权限 |
| ZOHO_IMPORT_ADDORUPDATE | true 或 false | false | 使用 ADD 或 UPDATE 选项在表中导入数据（即，附加新行及根据 IMPORT 操作中提供的匹配列更新现有行）的权限 |
| ZOHO_IMPORT_DELETEALLADD | true 或 false | false | 使用选项在表中导入数据的权限：删除所有现有记录及添加新记录 |
| ZOHO_SHARE | true 或 false | false | 对用户共享表/视图的权限 |
其他参数
| 参数 | 允许的值 | 默认值 | 描述 | 评论 |
|---|---|---|---|---|
| ZOHO_CRITERIA | 过滤条件应使用以下示例中给出的格式指定。它与 SQL 语言中的 WHERE 子句类似。 |
ZOHO_CRITERIA： 此参数允许您在对用户共享视图时应用过滤条件。共享用户访问报告时，通过过滤所查看数据，将对所共享报告应用所指定条件。 参阅以下链接以使用 ZOHO_CRITERIA： |
||
| ZOHO_INHERIT_PARENT_CRITERIA | true 或 false | false | 仅对报告（而不是表）有效。如果为 true，那么在共享时也会考虑其父表的条件 | |
| ZOHO_INVITE_MAIL | true 或 false | false | 共享时是否发送邀请邮件 | 对于白标客户： 如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。 |
| ZOHO_MAIL_SUBJECT | 仅当 ZOHO_INVITE_MAIL 为 true 时必需 | |||
| ZOHO_MAIL_MESSAGE | ||||
| ZOHO_INVITE_MAIL_CCME | true 或 false | false | 共享时是否将邀请邮件抄送给您 | 仅当 ZOHO_INVITE_MAIL 为 true 时，此参数才有效 |
SHARE VIEWS 中的可能错误代码
移除共享
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void removeshare(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string emails = "user1@zoho.com";
Dictionary<string, string> dic = new Dictionary<string, string>();
dic.Add("ZOHO_VIEWS", "Employee");
rc.RemoveShare(uri, emails,dic);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.removeshare(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func removeshare() {
url := reportclient.GetDbUri(email, dbname)
emailids := "user1@zoho.com"
params := map[string]string{}
params["ZOHO_ALLVIEWS"] = "true"
err := reportclient.RemoveShare(url, emailids, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
removeshare()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void removeshare() throws Exception
{
String uri = rc.getURI(email,dbname);
config.put("ZOHO_ALLVIEWS", true);
rc.removeShare(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.removeshare();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$emails = "Email Address";
$permissions = array('ZOHO_ALLVIEWS' => "true");
$report_client_request->removeShare($uri, $emails, $permissions);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def removeshare(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
params = {"ZOHO_ALLVIEWS":"true"}
rc.removeShare(uri,"Email Address",params)
obj = Sample()
obj.removeshare(obj.rc)
curl -d "ZOHO_ACTION=REMOVESHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&
ZOHO_API_VERSION=1.0&authtoken=************&
ZOHO_EMAILS=user1@zoho.com&ZOHO_ALLVIEWS=true"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="REMOVESHARE">
<result>success</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName",
"action": "REMOVESHARE",
"result": "success"
}
}
通过 Zoho Analytics 的“工作空间管理员 API”，您可以添加/移除工作空间管理员。使用 API 之前，建议阅读有关“多个工作空间管理员”的文档以更好地了解该 API。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=REMOVESHARE&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=abc@zoho.com&ZOHO_ALLVIEWS=true
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | REMOVESHARE | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 默认值 | 描述 | 评论 | |
|---|---|---|---|---|---|
| ZOHO_VIEWS | Table1,View1,View2,My View | 需要移除其共享的视图。可使用逗号分隔符传递多个视图。Note:ZOHO_VIEWS 是以 URL 编码格式编写的。下面给出没有编码的值：ZOHO_VIEWS=Table1,View1,View2,My View |
任一参数（ZOHO_VIEWS 或 ZOHO_ALLVIEWS）是必需参数。 | ||
| ZOHO_ALLVIEWS | true 或 false | false | 如果传递至此参数的值为 true，那么系统将移除对共享给对应用户的所有视图的共享 （用户是通过参数 ZOHO_EMAILS 中传递的电子邮件地址标识的） |
任一参数（ZOHO_VIEWS 或 ZOHO_ALLVIEWS）是必需参数。 | |
| ZOHO_EMAILS | user1@finepick.com, user2@finepick.com | 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：ZOHO_EMAILS=user1@finepick.com,user2@finepick.com |
必备参数 | ||
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于从白标域中移除共享视图。 | 可选 |
REMOVE SHARE 中的可能错误代码
添加工作空间管理员
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void adddbowner(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string emails = "user1@zoho.com";
rc.AddDbOwner(uri, emails, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.adddbowner(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func adddbowner() {
url := reportclient.GetDbUri(email, dbname)
emailids := "user1@zoho.com"
params := map[string]string{}
err := reportclient.AddDbOwner(url, emailids, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
adddbowner()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void adddbowner() throws Exception
{
String uri = rc.getURI(email,dbname);
rc.addDbOwner(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.adddbowner();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$emails = "user1@zoho.com";
$report_client_request->addDbOwner($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def adddbowner(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
rc.addDbOwner(uri,"user1@zoho.com")
obj = Sample()
obj.adddbowner(obj.rc)
curl -d "ZOHO_ACTION=ADDDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_EMAILS=EmailAddress1"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="ADDDBOWNER">
<result>success</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName",
"action": "ADDDBOWNER",
"result": "success"
}
}
此 API 用于对特定工作空间添加工作空间管理员。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=ADDDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ADDDBOWNER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 | 评论 | |
|---|---|---|---|---|
| ZOHO_EMAILS | user1@finepick.com, user2@finepick.com | 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：ZOHO_EMAILS=user1@finepick.com,user2@finepick.com |
必备参数 | |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于向白标域添加工作空间管理员。 | 可选 |
其他参数
| 参数 | 允许的值 | 默认值 | 描述 | 评论 |
|---|---|---|---|---|
| ZOHO_INVITE_MAIL | true 或 false | false | 共享时是否发送邀请邮件 | 对于白标客户： 如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。 |
| ZOHO_MAIL_SUBJECT | 仅当 ZOHO_INVITE_MAIL 为 true 时必需 | |||
| ZOHO_MAIL_MESSAGE |
ADD WORKSPACE ADMIN 中的可能错误代码
移除工作空间管理员
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void removedbowner(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
string emails = "user1@zoho..com";
rc.RemoveDbOwner(uri, emails, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.removedbowner(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func removedbowner() {
url := reportclient.GetDbUri(email, dbname)
emailids := "user1@zoho.com"
params := map[string]string{}
err := reportclient.RemoveDbOwner(url, emailids, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
removedbowner()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void removedbowner() throws Exception
{
String uri = rc.getURI(email,dbname);
rc.removeDbOwner(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.removedbowner();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$emails = "user1@zoho.com";
$report_client_request->removeDbOwner($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def removedbowner(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
rc.removeDbOwner(uri,"user1@zoho.com")
obj = Sample()
obj.removedbowner(obj.rc)
curl -d "ZOHO_ACTION=REMOVEDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_EMAILS=EmailAddress1"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="REMOVEDBOWNER">
<result>success</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "/api/EmailAddress/WorkspaceName",
"action": "REMOVEDBOWNER",
"result": "success"
}
}
此 API 用于从特定工作空间中移除工作空间管理员。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=REMOVEDBOWNER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | REMOVEDBOWNER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数 | 可能的值 | 描述 | 评论 | |
|---|---|---|---|---|
| ZOHO_EMAILS | user1@finepick.com, user2@finepick.com | 需要针对所指定视图移除对其的共享的用户电子邮件地址（以逗号分隔值形式）Note: ZOHO_EMAILS 是以 URL 编码格式编写的。下面给出没有编码的值：ZOHO_EMAILS=user1@finepick.com,user2@finepick.com |
必备参数 | |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于从白标域中移除工作空间管理员。 | 可选 |
其他参数
| 参数 | 允许的值 | 默认值 | 描述 | 评论 |
|---|---|---|---|---|
| ZOHO_INVITE_MAIL | true 或 false | false | 共享时是否发送邀请邮件 | 对于白标客户： 如果此参数设置为“true”，请在“共享 API”请求中使用白标域 URL 而不是 analyticsapi.zoho.com。 |
| ZOHO_MAIL_SUBJECT | 仅当 ZOHO_INVITE_MAIL 为 true 时必需 | |||
| ZOHO_MAIL_MESSAGE |
REMOVE WORKSPACE ADMIN 中的可能错误代码
获取共享信息
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getshareinfo(IReportClient rc)
{
string uri = rc.GetURI(EMAIL, DBNAME);
var result = rc.GetShareInfo(uri, null);
var list = result.GetGroupMembers();
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getshareinfo(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
authtoken = "************"
)
func getshareinfo() {
url := reportclient.GetDbUri(email, dbname)
shareinfo , err := reportclient.GetShareInfo(url)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(shareinfo.GroupMembers)
fmt.Println(shareinfo.UserInfo)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getshareinfo()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void shareinfo() throws Exception
{
String uri = rc.getURI(email,dbname);
Object shareinfoobj = rc.getShareInfo(uri,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.shareinfo();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getDbURI($EMAIL_ID, $DB_NAME);
$report_client_response = $report_client_request->getShareInfo($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getshareinfo(self,rc):
uri = rc.getDBURI(self.LOGINEMAILID,self.DATABASENAME)
result = rc.getShareInfo(uri)
print result.sharedUsers
obj = Sample()
obj.getshareinfo(obj.rc)
curl -d "ZOHO_ACTION=GETSHAREINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/EmailAddress/WorkspaceName" action="GETSHAREINFO">
<result>
<usershareinfo>
<shareinfo>
<email>user1@mydomain.com</email>
<permissions>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>true</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user4@mydomain.com</email>
<permissions>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>true</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user215@mydomain.com</email>
<permissions>
<perminfo viewname="finepick1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>userlf12@mydomain.com</email>
<permissions>
<perminfo viewname="Parent" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user33@mydomain.com</email>
<permissions>
<perminfo viewname="Parent" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
<perminfo viewname="sss" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user1@mydomain.com</email>
<permissions>
<perminfo viewname="finepick1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user115@mydomain.com</email>
<permissions>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>true</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user11@mydomain.com</email>
<permissions>
<perminfo viewname="grp_pv1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>true</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user214@mydomain.com</email>
<permissions>
<perminfo viewname="finepick1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user104@mydomain.com</email>
<permissions>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>true</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user10@mydomain.com</email>
<permissions>
<perminfo viewname="Table2" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
<shareinfo>
<email>user101@mydomain.com</email>
<permissions>
<perminfo viewname="Table1" sharedby="user@mydomain.com">
<permission>
<read>true</read>
<export>false</export>
<vud>false</vud>
<addrow>false</addrow>
<updaterow>false</updaterow>
<deleterow>false</deleterow>
<deleteallrows>false</deleteallrows>
<appendimport>false</appendimport>
<updateimport>false</updateimport>
<truncateimport>false</truncateimport>
<deleteupdateaddimport>false</deleteupdateaddimport>
<share>false</share>
</permission>
</perminfo>
</permissions>
</shareinfo>
</usershareinfo>
<publicshareinfo>
</publicshareinfo>
<privatelinkshareinfo>
</privatelinkshareinfo>
<groupshareinfo>
<groupmembers>
<member>user10@mydomain.com</member>
<member>user1@mydomain.com</member>
</groupmembers>
</groupshareinfo>
<dbownershareinfo>
<dbowners>
<member>user13@mydomain.com</member>
<member>user1@mydomain.com</member>
</dbowners>
</dbownershareinfo>
</result>
</response>
样本响应 JSON 格式：
{
"response":{
"uri":"\/api\/EmailAddress\/WorkspaceName",
"action":"GETSHAREINFO",
"result":{
"usershareinfo":[
{
"shareinfo":{
"email":"user1@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"true",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user4@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"true",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user215@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"finepick1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"userlf12@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Parent",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user33@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Parent",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
},
{
"perminfo":{
"viewname":"sss",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
},
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user1@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"finepick1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user115@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"true",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user11@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"grp_pv1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"true",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user214@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"finepick1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user104@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"true",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user10@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table2",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
},
{
"shareinfo":{
"email":"user101@mydomain.com",
"permissions":[
{
"perminfo":{
"viewname":"Table1",
"sharedby":"user@mydomain.com",
"permission":{
"read":"true",
"export":"false",
"vud":"false",
"addrow":"true",
"updaterow":"false",
"deleterow":"false",
"deleteallrows":"false",
"appendimport":"false",
"updateimport":"false",
"truncateimport":"false",
"deleteupdateaddimport":"false",
"share":"false"
}
}
}
]
}
}
],
"publicshareinfo":{
},
"privatelinkshareinfo":{
},
"groupshareinfo":{
"groupmembers":[
"user10@mydomain.com",
"user1@mydomain.com"
]
},
"dbownershareinfo":{
"dbowners":[
"user13@mydomain.com",
"user1@mydomain.com"
]
}
}
}
}
“获取共享信息 API”用于获取工作空间的所有共享信息。只有该工作空间的管理员（该工作空间的创建者）才能使用此 API。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName?ZOHO_ACTION=GETSHAREINFO&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETSHAREINFO | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
GET SHARE INFO 中的可能错误代码
“共享 API”中的错误代码
样本错误 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName" action="GETVIEWURL">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the Workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "GETVIEWURL",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the Workspace exists"
}
}
}
本节列示“共享 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 7003 | 请求中缺少必需参数。 | 发送与该特定操作相关的所有必需参数。 |
| 7103 | API URL 中提到的工作空间名称不存在。 | 请提供现有工作空间名称以获取共享详细信息。 |
| 7301 | 您（您的全名）无权执行此操作。只有工作空间管理员才具有此权限。 | 请提供该工作空间的管理员或所有者的认证令牌。 |
| 8026 | 缺少权限参数。 | 至少需要下列其中一个参数：[ZOHO_READ、ZOHO_EXPORT、ZOHO_VUD、ZOHO_ADDROW、ZOHO_UPDATEROW、ZOHO_DELETEROW、ZOHO_DELETEALLROWS、ZOHO_IMPORT_APPEND、ZOHO_IMPORT_ADDORUPDATE、ZOHO_IMPORT_DELETEALLADD、ZOHO_IMPORT_DELETEUPDATEADD、ZOHO_SHARE、ZOHO_VUD_SELCOL 和 ZOHO_DRILLDOWN]。 |
| 8027 | 找不到所提及的视图/工作空间。 | 请提供有效视图/工作空间名称。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8509 | ZOHO_EMAILS 参数中提供的电子邮件 ID 不正确或未使用电子邮件 ID 格式。 | 检查该参数中传递的电子邮件地址并提供正确电子邮件地址。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
如果遇到任何其他错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
嵌入 API
通过此 API，您可通过程序将 Zoho Analytics 中创建的嵌入报告和统计图表嵌入至网页/应用程序。这为开发人员提供了无缝创建将嵌入其网站和应用程序中的动态报告内容的绝佳机会。
获取视图 URL
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getviewurl(IReportClient rc)
{
string uri = rc.GetURI(EMAIL,DBNAME,TBNAME);
string result = rc.GetViewUrl(uri, null);
Console.WriteLine(result);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getviewurl(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func getviewurl() {
url := reportclient.GetUri(email, dbname, tbname)
viewurl , err := reportclient.GetViewUrl(url)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(viewurl)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getviewurl()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void getviewurl() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
String result = rc.getViewURL(uri,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getviewurl();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$view_url = $report_client_request->getViewUrl($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getviewurl(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
result = rc.getViewUrl(uri)
print result
obj = Sample()
obj.getviewurl(obj.rc)
curl -d "ZOHO_ACTION=GETVIEWURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETVIEWURL">
<result>
<viewurl>
https://analytics.zoho.com/ZDBDataSheetView.cc?&
OBJID=9999999999999&STANDALONE=true&REMTOOLBAR=true&
ZDB_THEME_NAME=blue
</viewurl>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName\/TableName",
"action": "GETVIEWURL",
"result":
{
"viewurl": "https://analytics.zoho.com/ZDBDataSheetView.cc?&
OBJID=9999999999999&STANDALONE=true&REMTOOLBAR=true&
ZDB_THEME_NAME=blue"
}
}
}
此 API 返回用于访问所提及视图的 URL。您需要提供工作空间名称和视图名称作为 API 的输入。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETVIEWURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETVIEWURL | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
GET VIEW URL 中的可能错误代码
获取嵌入 URL（仅适用于白标客户）
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
DBNAME = "Workspace Name";
TBNAME = "Table Name";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getEmbedURL(IReportClient RepClient)
{
string tableURI = RepClient.GetURI(EMAIL, DBNAME, TBNAME);
string result = RepClient.GetEmbedURL(tableURI, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getEmbedURL(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
dbname = "Workspace Name"
tbname = "Table Name"
authtoken = "************"
)
func getembedurl() {
url := reportclient.GetUri(email, dbname, tbname)
params := map[string]string{}
embedurl , err := reportclient.GetEmbedUrl(url, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(embedurl)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getembedurl()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String dbname = "Workspace Name";
String tbname = "Table Name";
String authtoken = "************";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void getembedurl() throws Exception
{
String uri = rc.getURI(email,dbname,tbname);
String result = rc.getEmbedURL(uri,config);
System.out.println(result);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getembedurl();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$DB_NAME = "Workspace Name";
$TABLE_NAME = "Table Name";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getURI($EMAIL_ID, $DB_NAME, $TABLE_NAME);
$criteria = "Department"='Finance';
$embed_url = $report_client_request->getEmbedURL($uri ,$criteria);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
DATABASENAME="Workspace Name"
TABLENAME="Table Name"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getembedurl(self,rc):
uri = rc.getURI(self.LOGINEMAILID,self.DATABASENAME,self.TABLENAME)
result = rc.getEmbedUrl(uri)
print result
obj = Sample()
obj.getembedurl(obj.rc)
curl -d "ZOHO_ACTION=GETEMBEDURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName
样本响应 XML 格式：
<response uri="/api/EmailAddress/WorkspaceName/TableName" action="GETEMBEDURL">
<result>
<embedurl>https://analytics.zoho.com/ZDBDataSheetView.cc?&
OBJID=100000000000026025&REMTOOLBAR=>true&FS=OS
&RSCONFIG=Ksp6SkShM5/PySm0q3lMQCeqwqe234423qe3BGQC4wp+YS6ahHG8e1j
035yQrpZwAZdq7I
</embedurl>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri":"\/api\/EmailAddress\/WorkspaceName\/TableName",
"action":"GETEMBEDURL",
"result": {"embedUrl":"https://analytics.zoho.com/ZDBDataSheetView.cc?&
OBJID=100000000000026025&REMTOOLBAR=true&FS=OS
&RSCONFIG=Ksp6SkShM5/PySm0q3lMQCeqwqe234423qe3BGQC4wp+YS6ahHG8e1j
035yQrpZwAZdq7I"}
}
}
“获取嵌入 URL API”用于获取特定表/视图的嵌入 URL。此 API 仅对白标管理员可用。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress/WorkspaceName/TableName?ZOHO_ACTION=GETEMBEDURL&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETEMBEDURL | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
URL 参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_CUSTOMDOMAIN （可选） |
true/false | 默认值为 false。 True - 这将返回嵌入 URL 以及您的域地址。 False - 这将返回嵌入 URL 以及 zoho 域地址。 |
| ZOHO_CRITERIA （可选） |
条件 | 如果未发送该参数，那么所有行将可见。如果已发送条件，那么只有与该条件相匹配的行才可见。 |
| ZOHO_VUD_PERMISSION （可选） |
true/false | 默认值为 false。 如果为 true，那么该视图有权查看底层数据。 如果为 false，那么该视图无权查看底层数据。 |
| ZOHO_INCLUDE_TOOLBAR （可选） |
true/false | 默认值为 false。 如果为 true，那么工具栏在嵌入方式下可见。 如果为 false，那么所有工具栏在嵌入方式下不可见。 |
| ZOHO_VALIDITY_PERIOD （可选） |
<number> |
控制嵌入 URL 的有效期。 默认值为 3600 秒（1 小时）。 此值以秒为单位。 |
| ZOHO_THEME_COLOR （可选） |
blue/brown | 主题颜色。 默认值为 blue |
| ZOHO_DATATYPE_SYMBOL （可选） |
true/false | 控制是否在表列中显示数据类型符号。 默认值为 false |
| ZOHO_SEARCH_BOX （可选） |
true/false | 控制是否在表中显示搜索框 |
| ZOHO_IS_SECURE （可选） |
true/false | 控制是否以安全方式访问 URL（http 或 https） |
| ZOHO_LEGEND_POSITION （可选） |
控制在图注上的显示位置 | |
| ZOHO_EXPORT_PERMISSION （可选） |
true/false | 默认值为 false。 如果设置为 true，那么该视图有权导出数据。 如果设置为 false，那么该视图无权导出数据。 |
GET EMBED URL 中的可能错误代码
“嵌入 API”中的错误代码
样本错误 XML 格式：
<response uri="/api/EmailAddress/Workspacename/TableName" action="GETVIEWURL">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the Workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress\/WorkspaceName",
"action": "GETVIEWURL",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the Workspace exists"
}
}
}
本节列示“嵌入 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 7103 | API URL 中提到的工作空间名称不存在。 | 检查请求 URL 中的工作空间名称，并提供有效的工作空间名称。 |
| 7138 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 8023 | 您无权执行此操作。 | 请联系我们的支持团队。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
用户管理 API
本节列示用于管理 Zoho Analytics 管理员帐户中的用户的“用户管理 API”。
“管理用户 API”用于在 Zoho Analytics 帐户中添加/删除/激活/停用用户。此 API 只能由 Zoho Analytics 帐户的管理员调用，以在其帐户中添加/激活/停用用户。
Note: 这些 API 不能用于在 Zoho 中创建用户帐户。这只是为了将现有的 Zoho 用户与管理员持有的 Zoho Analytics 帐户相关联。
获取用户
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getusers(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL);
var result = rc.GetUsers(uri, null);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getusers(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func getusers(){
url := reportclient.GetUserUri(email)
params := map[string]string{}
result , err := reportclient.GetUsers(url, params)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(result)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getusers()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void getusers() throws Exception
{
String uri = rc.getURI(email);
ArrayList resp = rc.getUsers(uri, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.getusers();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getUserURI($EMAIL_ID);
$result = $request->getUsers($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getusers(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
result = rc.getUsers(uri)
print result
obj = Sample()
obj.getusers(obj.rc)
curl -d "ZOHO_ACTION=GETUSERS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/Email Address" action="GETUSERS">
<result>
<user emailId="user+1@zoho.com" status="true" role="User" > </user>
<user emailId="user+2@zoho.com" status="true" role="workspace Admin" > </user>
<user emailId="user+3@zoho.com" status="true" role="Admin"> </user>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/Email Address",
"action": "GETUSERS",
"result": [
{
"emailId": "user+1@zoho.com",
"status": true,
"role": "User"
},
{
"emailId": "user+2@zoho.com",
"status": true,
"role": "Workspace Admin"
},
{
"emailId": "user+3@zoho.com",
"status": true,
"role": "Admin"
}
]
}
}
“获取用户 API”用于获取 Zoho Analytics 帐户中的用户。只有帐户管理员和工作空间管理员才能使用此 API 获取 Zoho Analytics 帐户中的用户列表。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETUSERS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETUSERS | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
GETUSERS 中的可能错误代码
添加用户
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void addUser(IReportClient RepClient)
{
string userURI = RepClient.GetURI(EMAIL);
string emailIds = "user1@zoho.com";
RepClient.AddUser(userURI, emailIds, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.addUser(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func adduser() {
url := reportclient.GetUserUri(email)
emailids := "user1@zoho.com"
err := reportclient.AddUser(url, emailids)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
adduser()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void adduser() throws Exception
{
String uri = rc.getURI(email);
rc.addUser(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.adduser();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "EmailAddress";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$emails = "user1@yourdomain.com,user2@yourdomain.com";
$report_client_request->addUser($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="EmailAddress"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def AddUser(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
emailIds = "user1@zoho.com"
rc.addUser(uri,emailIds)
obj = Sample()
obj.AddUser(obj.rc)
curl -d "ZOHO_ACTION=ADDUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_EMAILS=EmailAddress1,EmailAddress2"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="ADDUSER">
<result>
<message>User(s) added successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ADDUSER",
"result":
{
"message": "User(s) added successfully"
}
}
}
可使用此 API 向 Zoho Analytics 帐户添加用户（只要您是管理员）。默认情况下，用户添加时为“活动状态”，并且帐户中的活动用户数将相应增加。如果您的帐户已超过允许的用户数限制，那么新添加的用户将被设置为“已停用”。系统会触发向新添加的用户发送邀请邮件的操作。
Note: 此 API 仅用于向您（管理员）的 Zoho Analytics 帐户添加用户。此 API 不会在Zoho 中创建用户帐户。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ADDUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ADDUSER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_EMAILS | 用户电子邮件 ID | 此参数包含要在您（管理员）的 Zoho Analytics 帐户中添加的用户的电子邮件地址。 电子邮件地址间应使用逗号分隔。 Ex:ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于向白标域添加用户。 |
ADD USER 中的可能错误代码
移除用户
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void removeUser(IReportClient RepClient)
{
string userURI = RepClient.GetURI(EMAIL);
string emailIds = "user1@zoho.com";
RepClient.RemoveUser(userURI, emailIds, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.removeUser(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func removeuser() {
url := reportclient.GetUserUri(email)
emailids := "user1@zoho.com"
err := reportclient.RemoveUser(url, emailids)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
removeuser()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void removeuser() throws Exception
{
String uri = rc.getURI(email);
rc.removeUser(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.removeuser();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$emails = "user1@yourdomain.com,user2@yourdomain.com";
$report_client_request->removeUser($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def RemoveUser(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
emailIds = "user1@zoho.com"
rc.removeUser(uri,emailIds)
obj = Sample()
obj.RemoveUser(obj.rc)
curl -d "ZOHO_ACTION=REMOVEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_EMAILS=EmailAddress1"
https://analyticsapi.zoho.com/api/Email Address
样本响应 XML 格式：
<response uri="/api/Email Address" action="REMOVEUSER">
<result>
<message>User(s) removed successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "REMOVEUSER",
"result":
{
"message": "User(s) removed successfully"
}
}
}
此 API 用于从管理员的 Zoho Analytics 帐户中删除用户。如果移除/删除活动用户，那么与该帐户关联的用户数将减少。下面是用法详细信息。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=REMOVEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=Email Address
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | REMOVEUSER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_EMAILS | 用户电子邮件 ID | 此参数包含要从 Zoho Analytics 帐户中删除的用户的电子邮件地址。 电子邮件地址间应使用逗号分隔。 Ex:- ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com。请注意，从 Zoho Analytics 帐户中移除用户不会从 Zoho 中移除该用户。这只会从管理员的 Zoho Analytics 帐户中移除该用户。 |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于从白标域中移除用户。 |
REMOVE USER 中的可能错误代码
活跃用户
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void activateUser(IReportClient RepClient)
{
string userURI = RepClient.GetURI(EMAIL);
string emailIds = "user1@zoho.com";
RepClient.ActivateUser(userURI, emailIds, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.activateUser(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func activateuser() {
url := reportclient.GetUserUri(email)
emailids := "user1@zoho.com"
err := reportclient.ActivateUser(url, emailids)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
activateuser()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void activateuser() throws Exception
{
String uri = rc.getURI(email);
rc.activateUser(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.activateuser();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$emails = "user1@yourdomain.com,user2@yourdomain.com";
$report_client_request->activateUser($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def ActivateUser(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
emailIds = "user1@zoho.com"
rc.activateUser(uri,emailIds)
obj = Sample()
obj.ActivateUser(obj.rc)
curl -d "ZOHO_ACTION=ACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************
&ZOHO_EMAILS=Email Address"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/abc@zoho.com" action="ACTIVATEUSER">
<result>
<message>User(s) activated successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ACTIVATEUSER",
"result":
{
"message": "User(s) activated successfully"
}
}
}
可使用“激活用户 API”来激活用户。激活用户后，他/她将包含在活动用户总数内。如果达到该帐户的可用用户数限制，那么此 API 无法激活该用户。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=ACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | ACTIVATEUSER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_EMAILS | 用户电子邮件 ID | 此参数包含要在管理员的 Zoho Analytics 帐户中激活的用户的电子邮件地址。 电子邮件地址间应使用逗号分隔。 Ex:- ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于在白标域中激活用户。 |
ACTIVATE USER 中的可能错误代码
停用用户
下载客户端库：
C# |GO |JAVA |PHP |PYTHON
样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void deActivateUser(IReportClient RepClient)
{
string userURI = RepClient.GetURI(EMAIL);
string emailIds = "user1@zoho.com";
RepClient.DeActivateUser(userURI, emailIds, null);
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.deActivateUser(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func deactivateuser() {
url := reportclient.GetUserUri(email)
emailids := "user1@zoho.com"
err := reportclient.DeActivateUser(url, emailids)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println("Success")
}
}
func main() {
reportclient.SetAuthToken(authtoken)
deactivateuser()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
String emails = "abc@zoho.com";
Map config = new HashMap();
private ReportClient rc = new ReportClient(authtoken);
public void deactivateuser() throws Exception
{
String uri = rc.getURI(email);
rc.deActivateUser(uri,emails,config);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.deactivateuser();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $report_client_request->getUserURI($EMAIL_ID);
$emails = "user1@yourdomain.com,user2@yourdomain.com";
$report_client_request->deActivateUser($uri, $emails);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def DeActivateUser(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
emailIds = "user1@zoho.com"
rc.deActivateUser(uri,emailIds)
obj = Sample()
obj.DeActivateUser(obj.rc)
curl -d "ZOHO_ACTION=DEACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML
&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken
=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<response uri="/api/EmailAddress" action="DEACTIVATEUSER">
<result>
<message>User(s) de-activated successfully</message>
</result>
</response>
样本响应 JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "DEACTIVATEUSER",
"result":
{
"message": "User(s) de-activated successfully"
}
}
}
此 API 用于在管理员的 Zoho Analytics 帐户中停用所指定用户。您可使用“停用用户 API”来停用已激活用户。停用处于“活动状态”的用户后，用户数将下降。下面是用法详细信息。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=DEACTIVATEUSER&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************&ZOHO_EMAILS=EmailAddress1,EmailAddress2
常规参数
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | DEACTIVATEUSER | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
特定于操作的参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_EMAILS | 用户电子邮件 ID | 此参数包含要在 Zoho Analytics 帐户中停用的用户的电子邮件地址。 电子邮件地址间应使用逗号分隔。 Ex:- ZOHO_EMAILS=user1@yourdomain.com,user2@yourdomain.com |
| ZOHO_DOMAINNAME （仅适用于白标客户） |
域名 | 它用于在白标域中停用用户。 |
DEACTIVATE USER 中的可能错误代码
获取方案信息
下载客户端库：
C# |GO |JAVA |PHP |PYTHON 样本请求：
using ZReports;
namespace Test
{
AUTHTOKEN = "************";
EMAIL = "Email Address";
class Program
{
public IReportClient getClient()
{
IReportClient RepClient = new ReportClient(AUTHTOKEN);
return RepClient;
}
public void getplaninfo(IReportClient rc)
{
try
{
string uri = rc.GetURI(EMAIL);
var result = rc.GetPlanInfo(uri, null);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static void Main(string[] args)
{
Program obj = new Program();
IReportClient rc = obj.getClient();
obj.getplaninfo(rc);
}
}
}
package main
import (
"fmt"
"zoho/pkg/reportclient"
)
var(
email = "Email Address"
authtoken = "************"
)
func getplaninfo() {
url := reportclient.GetUserUri(email)
plan , err := reportclient.GetPlanInfo(url)
if(err != nil){
fmt.Println(err.ErrorMessage)
fmt.Println(err.ErrorCode)
fmt.Println(err.Action)
fmt.Println(err.HttpStatusCode)
}else{
fmt.Println(plan.Plan)
}
}
func main() {
reportclient.SetAuthToken(authtoken)
getplaninfo()
}
import com.adventnet.zoho.client.report.*;
public class Sample
{
String email = "Email Address";
String authtoken = "************";
private ReportClient rc = new ReportClient(authtoken);
public void planinfo() throws Exception
{
String uri = rc.getURI(email);
PlanInfo resp = rc.getPlanInfo(uri, null);
}
public static void main(String[] args) throws Exception
{
Sample obj = new Sample();
obj.planinfo();
}
}
<?php
require 'ReportClient.php';
$EMAIL_ID = "Email Address";
$AUTHTOKEN = "************";
$report_client_request = new ReportClient($AUTHTOKEN);
$uri = $request->getUserURI($EMAIL_ID);
$response = $request->getPlanInfo($uri);
?>
from __future__ import with_statement
from ReportClient import ReportClient
import sys
class Sample:
LOGINEMAILID="Email Address"
AUTHTOKEN="************"
rc = None
rc = ReportClient(self.AUTHTOKEN)
def getplaninfo(self,rc):
uri = rc.getUserURI(self.LOGINEMAILID)
result = rc.getPlanInfo(uri)
print result.rowsAllowed
print result.addon
obj = Sample()
obj.getplaninfo(obj.rc)
curl -d "ZOHO_ACTION=GETUSERPLANDETAILS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML
&ZOHO_API_VERSION=1.0&authtoken=************"
https://analyticsapi.zoho.com/api/EmailAddress
样本响应 XML 格式：
<?xml version="1.0" encoding="UTF-8" ?>
<response uri="/api/Email Address" action="GETUSERPLANDETAILS">
<result>
<plan>Standard</plan>
<addon>Projects Connector,BugTracker Connector,Google Analytics MultiClient Connector,Zendesk Connector,Google Adwords Connector,Creator Connector,Zoho Recruit Connector,QuickBooks Connector,Zoho Books Connector,MailChimp Connector</addon>
<billingDate>-1</billingDate>
<rowsAllowed>2000000</rowsAllowed>
<rowsUsed>6627</rowsUsed>
<TrialAvailed>false</TrialAvailed>
</result>
</response>
样本响应 JSON 格式：
{
"response": {
"uri": "/api/EmailAddress",
"action": "GETUSERPLANDETAILS",
"result": {
"plan": "Standard",
"addon": "Projects Connector,BugTracker Connector,Google Analytics MultiClient Connector,Zendesk Connector,Google Adwords Connector,Creator Connector,Zoho Recruit Connector,QuickBooks Connector,Zoho Books Connector,MailChimp Connector",
"billingDate": "-1",
"rowsAllowed": "2000000",
"rowsUsed": "6627",
"TrialAvailed": "false"
}
}
}
“方案信息 API”用于在 Zoho Analytics 帐户中获取用户方案详细信息。只有帐户管理员和工作空间管理员才能使用此 API 获取 Zoho Analytics 帐户中的用户方案信息。
http 请求
https://analyticsapi.zoho.com/api/EmailAddress?ZOHO_ACTION=GETUSERPLANDETAILS&ZOHO_OUTPUT_FORMAT=XML&ZOHO_ERROR_FORMAT=XML&ZOHO_API_VERSION=1.0&authtoken=************
常规参数
| 参数名称 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | GETUSERPLANDETAILS | 此参数指定 API 请求要执行的操作。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
GET PLAN INFO 中的可能错误代码
“用户管理 API”中的错误代码
样本错误消息：
The sample response sent from the server if the error is occured.
XML 格式：
<response uri="/api/EmailAddress" action="ADDUSER">
<error>
<code>6021</code>
<message>
Sorry, you cannot activate additional user(s). Your plan limit
allows you to have only 2 shared users.Kindly
Upgrade your plan to activate more users.
</message>
</error>
</response>
JSON 格式：
{
"response":
{
"uri": "\/api\/EmailAddress",
"action": "ADDUSER",
"error":
{
"code":6021,
"message": "Sorry, you cannot activate additional user(s).
Your plan limit allows you to have only 2
shared users.Kindly ;Upgrade your plan to activate
more users."
}
}
}
本节列示“用户管理 API”发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。可使用此项进行相应的错误处理。
错误代码
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 6021 | 因为用户数超出您的 Zoho Analytics 方案的允许限制，因此不允许激活用户。 | 您可以升级 Zoho Analytics 帐户，也可以将其他用户添加为附加组件。登录 Zoho Analytics 后，您可以通过点击顶部的“订阅”链接来管理您的方案。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8509 | ZOHO_EMAILS 参数中提供的电子邮件 ID 不正确或未使用电子邮件 ID 格式。 | 检查该参数中传递的电子邮件地址并提供正确电子邮件地址。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
如果遇到任何其他错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
单点登录集成（仅适用于白标客户）
本节列示只能由白标客户（完全品牌重塑）使用的 API，他们可使用这些 API 在应用程序中轻松实现单点登录从而以无缝形式管理用户。
Zoho Analytics 提供完整的白标（专用标签）解决方案。此解决方案支持对您的网站/应用程序进行单点登录 (SSO)。通过使用下面提到的过程，您可以为白标 Zoho Analytics 解决方案实现松散耦合的登录机制，它适用于您当前使用的几乎任何身份验证系统。这将涉及您的网站/应用程序中的程序更改（要在您的终端编写代码）。本页概述了设置、执行单元/集成测试以及 Zoho 第三方 SSO 集成的各个步骤。
设置阶段
- 向 Zoho Analytics 团队提供以下信息：
- 您的测试设置和生产设置的 IP
- 您的网站的登录和注销页面 URL（这些 URL 将处理来自 Zoho Analytics 的登录和注销请求；对于您的测试和生产设置也是必需的）
- 测试和生产设置的域/子域名称（CNAME 映射）。CNAME 将您的测试/生产子域映射至 analytics.cs.zohohost.com
- 填写以下 Zoho Creator 表单以设计您的自定义页面 - https://creator.zoho.com/zohodbhelp/domain-rebranding/#Form:DomainProperties
- 向 Zoho Analytics 团队提交以上信息后，我们会向您发送 API 密钥以供您使用。（此 API 密钥不同于
http://api.zoho.com/ 上提供的 API 密钥）
注册 API
样本请求：
curl -d "apikey=apikey&operation=signup&email=[email id of the user to signup]
&full_name=[Full Name of the user]"
https://[your domain]/sso
成功响应示例
{
"ticket":"666b88566441b69d1a137db824314b6a9be8959a75b1a1be8b951c6e18f352
bb2e068f7f697fa4879e365e19967a5b537a08c8e85058625130e54e8467d
85259",
"result":"success",
"zuid":5471
}
样本故障响应
{
"result":"failure",
"cause":"Invalid APIKey"
}
假定您的域 URL 为 analytics.finepick.com。
URL 格式
form method="POST" action="https://analytics.finepick.com/sso" target="_self"
input type= "hidden" name ="apikey" value="[your apikey]"
input type ="hidden" name ="operation" value ="signup"
input type ="hidden" name ="email" value ="[email id of the user to signup]"
input type ="hidden" name ="full_name" value ="[Full Name of the user]"
input type ="submit" name ="Sign Up" value ="submit"
/form
Important: 对于用户注册 API，您需要向 Zoho Analytics 发送 HTTPS POST 请求。
“注册 API”的输入参数
| 参数 | 描述 |
|---|---|
| 操作 | 值为“signup” |
| 电子邮件 | 要注册的用户的电子邮件 ID |
| full_name（可选） | 用户的全名 |
| apikey | 您的 API 密钥 |
针对“注册 API”的响应：
成功响应和失败响应都以 JSON 格式呈示。
| 返回值 | 描述 |
|---|---|
| 结果 | success/failure 如果 API 调用成功，那么 result 属性中将显示值 success；否则显示值 failure。 |
| zuid | Zoho 系统生成的 ID。对每个用户电子邮件地址唯一。 您需要为针对其调用注册 API 的用户存储此设置。 在后续阶段进行任何通信/故障诊断时，此设置很有用。 |
| ticket | 用户使用它来访问 Zoho Analytics 中的报告。您需要在 URL 中将其传递至 Zoho。 |
| cause | 仅当发生故障时，此属性才会显示在响应中。 |
登录 API
样本请求：
curl -d "apikey=apikey&operation=signin&email=[email id of the user to signup]"
https://[your domain]/sso
成功响应示例
{
"ticket":"666b88566441b69d1a137db824314b6a9be8959a75b1a1be8b951c6e18f352bb
2e068f7f697fa4879e365e19967a5b537a08c8e85058625130e54e8467d85259",
"result":"success",
"zuid":5471
}
样本故障响应
{
"result":"failure",
"cause":"Invalid APIKey"
}
假定您的域 URL 为 analytics.finepick.com。
URL 格式
form method="POST" action="https://analytics.finepick.com/sso" target="_self"
input type= "hidden" name ="apikey" value="[your apikey]"
input type ="hidden" name ="operation" value ="signin"
input type ="hidden" name ="email" value ="[email id of the user to signin]"
input type ="submit" name ="Sign In" value ="submit"
/form
Important: 对于用户登录 API，您需要向 Zoho Analytics 发送 HTTPS POST 请求。
“登录 API”的输入参数
| 参数 | 描述 |
|---|---|
| 操作 | 值为“signin” |
| apikey | 您的 API 密钥 |
| 电子邮件 | 要登录的用户的电子邮件地址 |
针对“登录 API”的响应：
成功响应和失败响应都以 JSON 格式呈示。
| 返回值 | 描述 |
|---|---|
| 结果 | success/failure 如果 API 调用成功，那么 result 属性中将显示值 success；否则显示值 failure。 |
| zuid | Zoho 系统生成的 ID。 对每个用户电子邮件地址唯一。 您需要为针对其调用登录 API 的用户存储此设置。 在后续阶段进行任何通信/故障诊断时，此设置很有用。 |
| ticket | 用户使用它来访问 Zoho Analytics 中的报告。 您需要在 URL 中将其传递至 Zoho。 |
| cause | 仅当发生故障时，此属性才会显示在响应中。 |
注销 API
样本请求：
curl https://[your domain]/ZDBCustomDomainLogin.ma?ZDBACTION=signout
URL 格式：
https://analytics.finepick.com/ZDBCustomDomainLogin.ma?ZDBACTION=signout
Important: 在服务器/应用程序中完成注销过程（清除应用程序凭证）后，您需要对以上 URL 执行 HTTP 301 重定向。一旦您执行此操作，系统会在您从 Zoho Analytics 注销后立即重定向至登录页面。
工作流测试场景
本节概述单元测试成功完成后要尝试的步骤。
先决条件：
- 确保将域名映射至相应的 Zoho Analytics 环境 (analytics.cs.zohohost.com)。对于此特定文档，我们假定此域映射为
https://analytics.finepick.com 。请将此项替换为您自己的映射 URL。 - Zoho Analytics 环境位于 analytics.cs.zohohost.com
测试登录流程
- 调用以上“注册 API”或“登录 API”并获取凭单。
- 按如下所示构造 URL 并调用。
https://analytics.finepick.com/oauthorize?zacode=[obtained_ticket]&state=https://analytics.finepick.com/ZDBHome.cc - 该凭单所标识的用户可执行操作直到该凭单被注销或所有 cookie 被清除（在此情况下，应再次执行步骤 2）。
测试注销流程
- 使用以上步骤登录后，从您的服务器/应用程序针对 Zoho Analytics 服务器调用“注销 API”。
- 尝试使用同一凭单以访问白标域，系统会将您重定向至网站的已注册登录页面。
测试“以另一用户身份登录”功能
此步骤要求您使用“注册 API”注册 2 个不同电子邮件地址。
- 以第一个用户身份测试登录流程
- 然后对用户 2 使用该凭单以访问网站（使用“测试登录流程”中概述的相同步骤）。- 已有一个会话处于活动状态时，域将忽略第二个凭单 - 所以您仍以用户 1 的身份见到该会话。
集成测试场景
网站驱动的登录流程
- 用户登录主网站。
- 用户点击用于访问白标站点的链接。
- 白标站点要求用户提供登录凭证，当前会话中找不到此凭证
- 所以 Zoho Analytics 会使用参数 serviceurl 将该请求发送至已注册登录 URL，该参数包含登录后请求将发送至的完整 URL（例如，
https://finepick.com/login?serviceurl=https://analytics.finepick.com） - 因为用户已登录，所以 finepick.com 会执行“登录 API”或“注册 API”调用，这取决于 finepick.com 是否已有该用户的 zuid。
- 通过新生成的凭单，finepick.com 将用户的浏览器引导至服务 URL（在此示例中为
https://analytics.finepick.com/oauthorize?zacode=[obtained_ticket]&state=https://analytics.finepick.com/ZDBHome.cc）。 - 现在，白标网站可识别该用户。
白标驱动的登录流程
- 用户直接访问白标域。
- 如果找不到该用户的登录凭证，那么 Zoho Analytics 会将该用户发送至使用参数 serviceurl 指定的已注册登录 URL。serviceurl 包含登录后请求应发送至的完整 URL（例如，
https://finepick.com/login?serviceurl=https://analytics.finepick.com） - finepick.com 的登录页面根据 finepick.com 中存储的数据收集并处理用户的登录凭证。
- 用户成功登录 finepick.com 后，如果服务 URL 为白标 URL，那么服务器应对当前已登录用户调用“登录 API”或“注册 API”并获取 zoho 凭单。
- 成功获取 zoho 凭单后，用户的浏览器应转至服务 URL 所指示的 URL（在此示例中为
https://analytics.finepick.com/oauthorize?zacode=[obtained_ticket]&state=https://analytics.finepick.com/ZDBHome.cc） - 现在白标站点 (Zoho Analytics) 可识别该用户。
网站注销流程：
- 用户点击网站中的注销 URL 时，该网站应调用 Zoho Analytics 的“注销 API”并使该凭单失效。
- 必须调用“注销 API”！
白标注销流程：
- 用户从报告站点注销时，系统会使用指向社区 URL 的 serviceurl 参数将他引导至主站点的注销 URL。
- Zoho 会在 Zoho 终端自动清除有关该用户的所有 cookie 和会话信息。
其他条款和条件：
- 生效之前，必须添加 Zoho 的条款和条件（指示该社区是在 Zoho 上）并给出 Zoho 的条款和条件 URL。准确措辞由您的帐户管理员给出。
- 您需要向 Zoho 团队提供该集成的完整演示。
API 中的错误代码
本节列示 Zoho Analytics API 发生故障时可能从 Zoho Analytics 服务器发送的所有可能错误响应代码。您可使用它来处理相应错误。错误将以 JSON 或 XML 格式返回。
错误代码和原因
样本错误 XML 格式：
<response uri="/api/abc@zoho.com/Employee" action="ADDROW">
<error>
<code>7103</code>
<message>
Workspace not found! Please check whether the Workspace exists
</message>
</error>
</response>
样本错误 JSON 格式：
{
"response":
{
"uri": "\/api\/abc@zoho.com\/Employee",
"action": "ADDROW",
"error":
{
"code":7103,
"message": "Workspace not found! Please check whether
the Workspace exists"
}
}
}
| 错误代码 | 原因 | 解决方案 |
|---|---|---|
| 6021 | 因为用户数超出您的 Zoho Analytics 方案的允许限制，因此不允许激活用户。 | 您可以升级 Zoho Analytics 帐户，也可以将其他用户添加为附加组件。登录 Zoho Analytics 后，您可以通过点击顶部的“订阅”链接来管理您的方案。 |
| 7003 | 请求中缺少必需参数。 | 发送与该特定操作相关的所有必需参数。 |
| 7101 | 同名工作空间已存在。 | 请提供另一名称。 |
| 7102 | API 请求 URL 中指定的工作空间名称为空。 | 检查 API 请求 URL，并提供有效的工作空间名称。 |
| 7103 | API URL 中提到的工作空间名称不存在。 | 请提供现有工作空间名称以获取共享详细信息。 |
| 7104 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 7105 | 工作空间中指定的视图名称不存在。 | 请提供有效视图名称。 |
| 7106 | 视图 ID 在工作空间中不存在。 | 请提供有效 OBJID。 |
| 7107 | 该列在所指定 Zoho Analytics 表中不存在。 | 请在 ZOHO_COLUMNNAME 参数中提供要删除的列的正确名称。 |
| 7111 | 带有该名称的表在此工作空间中已存在。 | 请提供另一名称。 |
| 7128 | 带有相同名称的列在 Zoho Analytics 表中已存在。 | 请对 ZOHO_COLUMNNAME 参数提供不同名称。 |
| 7138 | API 请求 URL 中指定的视图名称不存在。 | 检查请求 URL 中的视图名称并提供有效的视图名称。 |
| 7144 | 所提及文件夹在此工作空间中不存在。 | 请检查所提及文件夹是否可用。 |
| 7159 | 要删除的列用于报告、公式列、查询表等等。 | 无法删除带有关联视图的列。调用此“删除列 API”之前，请删除与此列相关的关联视图和公式列。 |
| 7161 | 此 API 中指定的 Zoho Analytics 表是系统表（针对服务集成创建的表）。 | 不允许在系统表中添加列。使用此 API 时只能在非系统表中添加列。 |
| 7165 | 所指定工作空间是无法删除的系统工作空间（专为其他 Zoho 服务集成创建的工作空间）。 | 无法删除系统工作空间。 |
| 7301 | 您（您的全名）无权执行此操作。只有工作空间管理员才具有此权限。 | 请提供该工作空间的管理员或所有者的认证令牌。 |
| 7507 | 在所提及列中输入的值未遵循所指定数据类型。 | 检查该列的值并按所指定数据类型提供值。 |
| 7511 | 所提及列为必需列。 | 应对该必需列指定值。 |
| 8002 | 所指定条件无效。 | 请提供有效条件。 |
| 8004 | 条件中所提及列不在该表中。 | 请检查列名并提供有效名称。 |
| 8016 | 对于 INSERT 或 UPDATE 操作，您需要至少一个列。 | 应提供至少一个带有值的列。 |
| 8023 | 您无权执行此操作。 | 请联系我们的支持团队。 |
| 8024 | 不允许执行“复制工作空间”操作。 | 请检查 URL 中提供的工作空间密钥。 |
| 8025 | 无效自定义域。 | 请提供有效域名。 |
| 8026 | 缺少权限参数。 | 至少需要下列其中一个参数：[ZOHO_READ、ZOHO_EXPORT、ZOHO_VUD、ZOHO_ADDROW、ZOHO_UPDATEROW、ZOHO_DELETEROW、ZOHO_DELETEALLROWS、ZOHO_IMPORT_APPEND、ZOHO_IMPORT_ADDORUPDATE、ZOHO_IMPORT_DELETEALLADD、ZOHO_IMPORT_DELETEUPDATEADD、ZOHO_SHARE、ZOHO_VUD_SELCOL 和 ZOHO_DRILLDOWN]。 |
| 8027 | 找不到所提及的视图/工作空间。 | 请提供有效视图/工作空间名称。 |
| 8504 | 所需参数不正确或未发送。 | 请发送带有有效数据的参数。 |
| 8506 | 所提及参数的已发送次数超过所需次数。 | 检查响应中提及的额外参数并移除。 |
| 8509 | ZOHO_EMAILS 参数中提供的电子邮件 ID 不正确或未使用电子邮件 ID 格式。 | 检查该参数中传递的电子邮件地址并提供正确电子邮件地址。 |
| 8516 | 所提及参数中传递了无效值。 | 对所提及参数提供有效数据。 |
| 8533 | URL 中提供的用户电子邮件地址为错误格式。 | 请提供有效电子邮件地址。 |
| 8534 | 无效的 JSON 格式。 | 请提供有效 JSON 数据。 |
| 15000 | 目标工作空间中缺少复制所指定报告时所需的表。 | 检查目标工作空间并创建缺少的表。 |
| 15001 | 目标工作空间中缺少复制所指定报告时所需的列。 | 检查目标工作空间并在复制报告之前创建该列。 |
| 15002 | 目标工作空间中缺少复制所指定报告时所需的公式列。 | 检查目标工作空间并在复制报告之前创建公式列。 |
| 15005 | 所指定报告名称已存在于目标工作空间中。 | 检查目标工作空间中是否存在同名报告。尝试重命名源报告或目标工作空间中的报告，然后再次调用该 API。 |
| 15007 | 权限不足，无法复制报告。 | 检查复制工作空间密钥是否有效。 |
| 15009 | 所指定公式列名已存在于目标工作空间中。 | 检查公式列是否已被复制，或者尝试重命名源表或目标工作空间中的公式列，然后再次调用该 API。 |
| 15010 | API 请求中指定的公式列名称不在源表中。 | 检查 ZOHO_FORMULATOCOPY 参数中指定的公式列名称是否正确。 |
| 15012 | API 请求中指定的报告不在源工作空间中。 | 检查 ZOHO_VIEWTOCOPY 参数中指定的报告是否正确并可用。 |
如果出现上述任何错误以外的任何错误，请通过电子邮件将 API 请求 URL 参数和错误响应详细信息发送至
客户端库
客户端库是基于原始 HTTP API 的编程语言包装器。这使开发者能够在相应的编程语言中轻松地使用 Zoho Analytics API。当前我们支持以下编程语言库：
Java 库
Java 客户端库使用对应 Java 语言的易用方法包装 Zoho Analytics 的基于 HTTP 的原始 API。这允许 Java 开发者轻松使用 Zoho Analytics API。
Javadoc
下载 Java 客户端库
从以下链接下载 Java 客户端库。
C# 库
C# 客户端库使用对应 C# .Net 平台的易用方法包装 Zoho Analytics 的基于 HTTP 的原始 API。这允许 C# .Net 开发者轻松使用 Zoho Analytics API。
先决条件：
在应用程序中使用 C# 客户端库代码之前，建议阅读
csharpdoc
下载 C# 客户端库：
从以下链接下载 C# 客户端库 (dll)。
使用这些 .dll 文件添加对 C# 项目的引用。通过此项，您将能够使用可用函数执行
方法摘要：
C# .Net 开发者需要创建 ReportClient 对象以访问库函数。以下是样本代码片段。
IReportClient RepClient = new ReportClient("-----your authtoken-----");
ReportClient 构造函数具有一个名为 AuthToken 的自变量。您可在
Python 库
Python 客户端库使用对应 Python 语言的易用方法包装 Zoho Analytics 的基于 HTTP 的原始 API。这允许 Python 开发者轻松使用 Zoho Analytics API。
Pythondoc
下载 Python 客户端库
从以下链接下载 Python 客户端库。
PHP 库
PHP 客户端库使用对应 PHP 语言的易用方法包装 Zoho Analytics 的基于 HTTP 的原始 API。这允许 PHP 开发者轻松使用 Zoho Analytics API。
phpdoc
下载 php 客户端库
从以下链接下载 php 客户端库。
GO 库
GO 客户端库使用对应 GO 语言的易用方法包装 Zoho Analytics 的基于 HTTP 的原始 API。这允许 GO 开发者轻松使用 Zoho Analytics API。
godoc
下载 go 客户端库
从以下链接下载 go 客户端库。
使用 go 客户端的步骤
以下指示信息帮助您在 Go 应用程序中使用 Zoho Analytics Go 客户端库。
- 从上述下载链接下载 Go 客户端库。
- 解压 ZIP 文件。
- 将 zoho/pkg/reportclient/reportclient.go 复制到 GO_PATH/src/ 文件夹。
- 转至 zoho/pkg/reportclient 文件夹。
- 执行以下命令：
- go install
- 可将 Zoho Analytics 客户端库与每个 API 中提供的样本代码配合使用。
Google AppEngine 客户端库
Google AppEngine 客户端库是
通过使用此 API 库，您可将 Zoho Analytics 用作 Google AppEngine 应用程序的报告引擎。您可以将所需数据从 Google 应用程序推送到 Zoho Analytics，并在 Zoho Analytics 中创建报告/分析。必要时，也可以将这些报告重新嵌入到您的应用程序中。
Pythondoc
下载
从以下链接下载 Python 客户端库。
Zoho CloudSQL
Zoho CloudSQL 是一种中间件技术，允许客户通过熟悉的
Zoho CloudSQL 是什么？
Zoho 凭借其丰富的固有生产力应用程序和业务应用程序收集、挖掘大量结构化数据和非结构化数据并向用户展示。对于在 Zoho 平台上工作的开发者，为了扩展和定制各种 Web 服务，它为大多数 Zoho 服务提供了基于 HTTPS 的全面 Web API。当前
Zoho CloudSQL 是一个平台 API 服务，允许开发者使用
开发者可以通过网络执行 SELECT、INSERT、UPDATE 和 DELETE SQL 语句，以使用 CloudSQL 处理 Zoho 服务中的数据。CloudSQL 的另一个强大方面是支持多种 SQL 方言，开发者可以使用它们构建 SQL 查询。CloudSQL 支持以 ANSI、Oracle、Microsoft SQL Server、IBM DB2、MySQL、PostgreSQL 和 Informix 方言中的任何一种编写的 SQL 查询。这允许开发者轻松采用 CloudSQL，只要他们熟悉所提到的任何一种工作空间方言。
Zoho Analytics 和 Zoho CloudSQL
Zoho Analytics CloudSQL 实现的关键亮点
Zoho Analytics CloudSQL 实现的关键亮点包括：
- 基于 HTTPS 的 SQL 查询
- 当前支持通过 HTTPS 进行 SELECT 查询
- 即将支持 INSERT、UPDATE 和 DELETE 语句
- 支持使用多种方言（包括 ANSI、Oracle、Microsoft SQL Server、IBM DB2、MySQL、Sybase、PostgreSQL 和 Informix 方言）执行 SQL 查询。用户可执行使用以上任一方言编写的查询。
- 启用应用程序连接，即，使用
Zoho Analytics JDBC 驱动程序 与 Zoho Analytics 服务交互。- 即将支持 ODBC 驱动程序
SQL 查询实体映射
要构造和执行 SQL 查询，您需要先识别将对其运行 SQL 查询的实体。对构造 SQL 查询很重要的基本实体包括工作空间、表和列。
下节描述 Zoho Analytics 中的映射，此映射将映射至 SQL 查询所需的基本实体。您需要使用此映射来构造要执行的 SQL 查询。
在
| SQL 查询实体 | Zoho Analytics 映射 |
|---|---|
| 工作空间 | 映射至 |
| 表 | 映射至 |
| 列 | 映射至 |
样本：
以下是针对 Zoho Analytics 执行的 CloudSQL 查询的示例：
涉及 Zoho Analytics 的实体：
Zoho Analytics 中的工作空间名称：“
表名：Sales
所涉及列：Customer Name、Sales、Cost 和 Region
SQL SELECT 查询：
select “Customer Name”,Sales,Cost,“Profit (Sales)” from Sales where Region = 'East’
以上查询将从 Zoho Analytics 的 Super Store Sales 工作空间中的 Sales 表获取记录（它们来自区域“East”）。
Zoho Analytics CloudSQL - API 规范
使用 Zoho Analytics API 进行基于 HTTP 的 SQL 查询
Zoho Analytics 以 HTTP Web API 扩展的形式实现了 Zoho CloudSQL 技术。通过使用 HTTP API，用户可通过提供 SQL 查询来查询 Zoho Analytics 工作空间。
当前 Zoho Analytics 仅支持 SQL SELECT 查询。即将支持其他 SQL 语句，例如，INSERT、UPDATE 和 DELETE。
通过使用 SQL Select 语句，开发者可从单个表/查询表获取数据，或者连接 Zoho Analytics 中的一个或多个表。可以不同响应格式（包括 CSV、PDF、HTML、JSON 和 XML）获取数据。
SQL SELECT 查询请求格式：
Zoho Analytics 使用
http 请求
https://analyticsapi.zoho.com/api/<Email>/<Workspacename>/<Tablename>
查询字符串参数：
| 参数 | 可能的值 | 描述 |
|---|---|---|
| ZOHO_ACTION | EXPORT | 此参数指定 API 请求要执行的操作。Note:ZOHO_ACTION 参数的值的大小写应与本文档中给出的大小写相同（大写）。 |
| ZOHO_OUTPUT_FORMAT | XML/JSON/CSV/PDF/HTML/IMAGE | 此参数指定响应的输出格式。 |
| ZOHO_ERROR_FORMAT | XML/JSON | 如果尝试处理请求时发生错误，请指定响应的输出格式。 |
| authtoken | 用户身份验证令牌 | 身份验证令牌是认证用户以访问 Zoho 帐户的唯一令牌。 |
| ZOHO_API_VERSION | 1.0 | 编写应用程序（/服务）时所基于的 Zoho Analytics API 版本。此参数允许 Zoho Analytics 处理基于之前版本的应用程序。最新 API 版本为 1.0。 |
SQL 查询（作为 POST 参数）：
确切的 SQL Select 查询必须作为 POST 参数传递至 API 请求。此查询应作为参数 ZOHO_SQLQUERY 的值进行传递。确切的 SQL Select 查询字符串应使用 URL 进行编码。
样本查询：
样本 Select 查询将以 CSV 格式获取“finance”部门的所有员工及其详细信息。
所涉及实体：
工作空间名称：所涉及 EmployeeDB 表：Employee 和 EmpDetails
SELECT 查询（作为 POST 参数）：（请注意，查询应使用 URL 进行编码）
ZOHO_SQLQUERY=select empdet.Name Name,empdet.DOB Date_Of_Birth,empdet.Address Address,emp.BasicSal BasicPay,round(emp.BasicSal + emp.Allowance,2) Salary from Employee emp inner join EmpDetails empdet on emp.ID = empdet.ID where emp.Dept = 'Finance'
使用 URL 进行编码的 Select 查询（作为 POST 参数）：
&ZOHO_SQLQUERY=select%20empdet.Name%20Name%2Cempdet.DOB%20Date_Of_Birth%2Cempdet.Address%20Address%2Cemp.BasicSal%20BasicPay%2Cround%28emp.BasicSal%20%2B%20emp.Allowance%2C2%29%20Salary%20from%20Employee%20emp%20inner%20join%20EmpDetails%20empdet%20on%20emp.ID%20%3D%20empdet.ID%20where%20emp.Dept%20%3D%20%27Finance%27
样本成功响应：
下面给出上述查询的样本响应（CSV 格式）。CSV 响应的第一行包含列名：
Name,Date_Of_Birth,Address,BasicPay,Salary
Akram,"10 Dec, 1979 00:00:00",california, $10,000 , $10,500
....
Zoho Analytics CloudSQL 的 JDBC 驱动程序
示例
示例 Java 代码片段显示如何注册 Zoho Analytics CloudSQL JDBC 驱动程序、获取
连接、 创建语句 以及执行查询。
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class ZohoReportsCloudSQL
{
public static void main(String args[])
{
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try
{
Class.forName("com.zoho.cloudsql.jdbc.ZohoReportsDriver");
Properties conProps = new Properties();
conProps.put("ZOHO_API_KEY","abcd");
// Zoho username to login to Zoho service
conProps.put("user","david");
// Zoho password to login to Zoho service
conProps.put("password","davidpwd");
// Uncomment this incase you need proxy settings
/*
// Proxy host name to connect the internet
conProps.put("PROXYSERVER","proxy_hostname");
// Proxy port to connect the internet
conProps.put("PROXYPORT","proxy_port");
// Proxy user name to connect the internet
conProps.put("PROXYUSERNAME","proxy_username");
// Proxy password to connect the internet
conProps.put("PROXYPASSWORD","proxy_password");
*/
/* Important Note: Connection is single threaded in Zoho Analytics */
// david is the admin of the Workspace 'Sales'
con = DriverManager.getConnection("https://analyticsapi.zoho.com/" +
"api/david/Sales",conProps);
stmt = con.createStatement();
String sql ="select * from <tablename>";
rs = stmt.executeQuery(sql);
}
catch(SQLException se)
{
// handle any errors
System.out.println("SQLException: " + se.getMessage());
System.out.println("Zoho Analytics Error code: " + se.getErrorCode());
}
catch(Exception e)
{
// handle the exception
}
finally
{
if(rs != null)
{
try
{
rs.close();
}
catch(SQLException sqlEx) { } // ignore
}
if(stmt != null)
{
try
{
stmt.close();
}
catch (SQLException sqlEx) { } // ignore
}
if(con != null)
{
try
{
con.close();
}
catch (SQLException sqlEx) { } // ignore
}
}
}
}
CloudSQL 允许用户对 Zoho Analytics 中存储的结构化数据执行 SQL 查询，它也很自然地支持数据库连接标准，例如，
通过提供此 JDBC 驱动程序，开发者不必了解
- Zoho Analytics JDBC 驱动程序下载
- Zoho Analytics JDBC 驱动程序
- Zoho Analytics 的 JDBC 连接 URL
- 示例
- 要保存在 JDBC 驱动程序类路径中的 JAR
- JDBC 类型与 Zoho Analytics 数据类型的映射
- 通过工作空间可视化工具连接 Zoho Analytics
- DBVisualizer
- Squirrel SQL 客户端
Zoho Analytics JDBC 驱动程序下载
从以下链接下载 Zoho Analytics JDBC 驱动程序。
Javadoc
Zoho Analytics JDBC 驱动程序的 javadoc JDBC 接口的 javadoc （java.sql 包）
Zoho Analytics JDBC 驱动程序
要使用 JDBC 驱动程序，您需要具有 zoho 登录电子邮件地址和密码。当前您只能使用 JDBC 驱动程序执行 Select 查询。即将支持其他 SQL 语句。
在 JDBC 中，
要了解更多相关信息，请参阅
Zoho Analytics 的 JDBC 连接 URL
https://analyticsapi.zoho.com/api/<zoho_username_dbowner>/<Workspacename>?user=<zoho_username>&password=<zoho_password>
示例
代码块中显示了样本代码。
还可使用以下方法来获取连接：
DriverManager.getConnection("https://analyticsapi.zoho.com/api/david/Sales?" +
"david","davidpwd");
DriverManager.getConnection("https://analyticsapi.zoho.com/api/david/Sales?" +
"user=david&password=davidpwd");
要保存在 JDBC 驱动程序类路径中的 JAR
JDBC 类型与 Zoho Analytics 数据类型的映射
下表提供 Zoho Analytics 数据类型与 JDBC SQL 类型之间的映射。使用此映射在您的 Java 代码中处理从 Zoho Analytics 获取的数据。
| Zoho Analytics 数据类型 | JDBC SQL 类型 |
|---|---|
| 纯文本 | |
| 多行文本 | |
| 电子邮件 | |
| 自动编号 | |
| 数字 | |
| 正数 | |
| 小数 | |
| 货币 | |
| 百分比 | |
| 日期 | |
| 判定框 |
通过工作空间可视化工具连接 Zoho Analytics
Zoho Analytics JDBC 驱动程序支持通过以下工作空间可视化工具连接至 Zoho Analytics。
- DBVisualizer
- Squirrel SQL 客户端
DbVisualizer 工具
您可执行以下步骤以通过
第 1 步：创建新的驱动程序名称
- 从工具栏菜单中点击工具 > 驱动程序管理器。驱动程序管理器对话框将打开。
- 在驱动程序设置选项的名称字段中指定新驱动程序的名称（即，ZohoReportsDriver）
- 在 URL 格式字段中，按以下格式输入 URL：
https://analyticsapi.zoho.com/api/<zoho_user_email_address>/<zoho_database_name>。 - 提供用于连接 Zoho Analytics 的 Zoho Analytics JDBC 驱动程序类名 (com.zoho.cloudsql.jdbc.ZohoReportsDriver)。
- 在驱动程序文件路径组选项中，在用户指定的页签上点击文件图标以添加 JAR 文件。浏览并添加 Zoho Analytics JDBC 驱动程序的所有相关 JAR 文件。
- 关闭向导。
第 2 步：创建新的工作空间连接
- 点击“工作空间列表”窗口中的“创建新的工作空间连接”图标。这会提示您选择“使用向导”或“无向导”。
- 选择“使用向导”选项。这将打开新建连接向导。
- 输入新工作空间连接的别名，然后点击下一步。
- 从下拉列表中选择相应工作空间驱动程序（ZohoAnalytics 驱动程序），然后点击“下一步”按钮。
- 在“工作空间 URL”字段中，指定要连接的工作空间的 URL，如下所示。
格式：https://analyticsapi.zoho.com/api/<zoho_user_email_address>/<zoho_database_name>
示例：https://analyticsapi.zoho.com/api/david@zoho.com/Sales - 指定 Zoho 登录电子邮件地址和密码以用于身份验证，然后点击完成。
- 点击“完成”以完成新连接的创建。
连接概述
在工作空间对象树中选择连接对象时，“连接概述”将列示该工具中配置的所有工作空间连接。要连接至您的 Zoho Analytics 帐户，请双击 Zoho Analytics 连接。这将列示您的帐户中的所有工作空间及表。
执行 SQL SELECT 查询
遵循以下步骤以在您的 Zoho Analytics 工作空间中执行 SQL SELECT 查询。
- 从工具栏中点击“创建新的 SQL 命令”页签图标。
- 从“工作空间”下拉列表中选择工作空间名称。
- 在“查询”区域中指定 SQL SELECT 查询，然后运行该查询。
- 通过该工具，只能使用 SQL SELECT 查询访问 Zoho Analytics。
Squirrel SQL 客户端
还可通过
创建新驱动程序定义的步骤
通过遵循以下步骤，创建新的驱动程序定义以指定 JDBC 驱动程序。
- 从工具栏菜中单点击窗口 > 查看驱动程序。
- 在“驱动程序列表”窗口中点击“创建新的驱动程序”(+) 图标。这将打开添加驱动程序向导。
- 在“名称”字段中指定驱动程序的名称（即，ZohoReportsDriver）。
- 在示例 URL 字段中，输入 URL 格式 https://analyticsapi.zoho.com/api/
/ - 在网站 URL 中指定 https://zohoreportsapi.wiki.zoho.com/JDBC-Driver.html，这允许您存储链接。
- 打开额外类路径页签并点击添加。您会发现用于添加 JAR 文件的选项。
- 为确保正确添加，请点击列示驱动程序按钮。Zoho Report JDBC 驱动程序类路径中的类名将列示在类名下拉列表中。
- 点击确定。
添加别名的步骤
别名包含用于连接至工作空间的所有配置。通过遵循以下步骤，为 Zoho Analytics 创建新的别名以指定连接参数。
- 从工具栏菜中单点击窗口 > 别名。
- 在“别名列表”窗口中点击“创建新的别名”(+) 图标。这将打开添加别名向导。
- 在名称字段中指定工作空间连接的别名。
- 从驱动程序下拉列表中选择对应此别名的驱动程序。
- 在 URL 字段中，指定要连接的工作空间的 URL。
格式：https://analyticsapi.zoho.com/api/<zoho_user_email_address>/<zoho_database_name>
示例：https://analyticsapi.zoho.com/api/david@zoho.com/Sales - 指定 Zoho 用户名和密码。这是可选操作。您可保存用户凭证（在此处指定）以便上传更多数据。
- 测试按钮通过尝试连接至您的别名，以使您能够确保所输入数据是正确的。
- 点击确定以保存别名定义。
连接至 Zoho Analytics 工作空间
遵循以下步骤以连接至 Zoho Analytics 中的工作空间
- 新创建的别名将列示在别名列表窗口中。右键点击别名，然后点击连接。
- 这将建立与您的 Zoho Analytics 帐户的连接，对象树将显示 Zoho Analytics 中报告工作空间的结构。
执行 SQL SELECT 查询
可按如下所示从 SQL 页签执行 SQL SELECT 查询。
- 打开 SQL 页签。
- 指定所需 SQL SELECT 查询以在 Zoho Analytics 工作空间中执行。
- 点击会话窗口工具栏中的运行 SQL 图标以执行该查询。
- 通过该工具，只能在 Zoho Analytics 中执行 SQL SELECT 查询。
CloudSQL 客户端库
为使开发者能够轻松使用 Zoho Analytics CloudSQL HTTP API，我们提供了使用以下给定编程语言的客户端库。
- Java 客户端库
- Python 客户端库
- CSharp 客户端库
Java 客户端库
Java 客户端库使用对应 Java 语言的易用方法包装 Zoho Analytics 的 HTTP API。如果不想使用
有关将 CloudSQL 与 Java 客户端 API 配合使用的样本代码片段：
ReportClient rc = Config.getReportClient();
rc.login(Config.LOGINNAME,Config.PASSWORD);
String uri = rc.getURI(Config.LOGINNAME,Config.DATABASENAME);
String sql = "select \"Customer Name \",Sales,Cost, \"Profit (Sales) \" from Sales where Region = 'East'";
rc.exportDataUsingSQL(uri,"CSV",new File("Test.csv"),sql,null);
有关 Java 客户端库的更多详细信息，请参阅此
Python 客户端库
Python 客户端库使用对应 Python 语言的易用方法包装 Zoho Analytics 的 HTTP API。
有关将 CloudSQL 与 Python 客户端 API 配合使用的样本代码片段：
ReportClient rc = ReportClient(Config.APIKEY)
rc.login(Config.LOGINNAME,Config.PASSWORD)
uri = rc.getDBURI(Config.LOGINNAME,Config.DATABASENAME)
sql = "select Region from StoreSales"
rc.exportDataUsingSQL(uri,"CSV",sys.stdout,sql,None)
有关 Python 客户端库的更多详细信息，请参阅此
C# 客户端库
C# 客户端库使用对应 C# .Net 编程语言的易用方法包装 Zoho Analytics 的 HTTP API。
有关将 CloudSQL 与 C# 客户端 API 配合使用的样本代码片段：
IReportClient RepClient = new ReportClient("---authtoken---");
string WorkspaceURI = RepClient.GetURI("user@sampledomain.com", "MyWorkspace");
RepClient.ExportData(WorkspaceURI, "XML", "Output.xml", "select * from MyTable", null);
有关 C# 客户端库的更多详细信息，请参阅此
受支持的 SQL
用户可使用以下任意给定工作空间 SQL 方言来提供 SQL SELECT 查询。遵循相应链接以了解有关每种给定工作空间方言中受 Zoho Analytics CloudSQL 实现支持的 SQL 语句及函数的更多信息。
- ANSI SQL
- Oracle
- SQL Server
- MySQL
- DB2
- Sybase
- Informix
- PostgreSQL
在 CloudSQL 中，Zoho Analytics 支持以下 SELECT 查询语法和内置函数。
受支持的 SELECT 查询语法：
以下是 SELECT 语法定义中使用的约定：
| 约定 | 含义 | 示例 |
|---|---|---|
| 方括号 [ ] | 指示括在其中的自变量在语法中表示可选 | DIGITS [.PRECISION ] |
| 括号后跟加号 ( )+ | 指示括在其中的自变量可能多次出现 | ( DIGIT )+ |
| 括号后跟星号 ( )* | 指示括在其中的自变量可能出现零次或多次 | SELECT column_name ( , column_name)* FROM table_name |
| 问号 ? | 指示自变量前加上问号“?”表示可选。相当于方括号 [ ] | <INTEGER> ( "." <INTEGER> )? |
| 竖线 | 竖线指示选项 | (DISTINCT |
| UPPER CASE | 大写文本指示不区分大小写的文件名或目录名、命令、命令关键字、初始化参数或数据类型。 | SELECT column_name FROM table_name |
| 小写 | 小写文本指示工作空间对象，例如，表名、列名等等。 | DELETE FROM table_name WHERE condition |
SELECT 语法：
SELECT [ DISTINCT | ALL ] ( ( column_clause ( "," column_clause )* ) | "*" ) [ FROM table_expression_clause ] [ where_clause ] [ group_by_clause ] [ having_clause ] [ order_by_clause ] [ limit_clause ]
column_clause：
( expression | table_name.* | table_name.columnname | table_name.column_name | column_name ) [ [ AS ] alias_name ]
table_expression_clause：
( table_name ) [ AS alias_name ] ( "," ( table_name ) [ AS alias_name ])*
where_clause：
WHERE (<Left Where Expression>(= | < | > | <= | >= | != | LIKE | NOT LIKE | BETWEEN) <Right Where Expression>) ( (OPERATOR ) (<Left Where Expression> (= | < | > | <= | >= | != | LIKE | NOT LIKE | BETWEEN) <Right Where Expression>)*
运算符包括 AND/OR
group_by_clause :
GROUP BY expression ( "," expression )*
having_clause：
HAVING condition
order_by_clause：
ORDER BY (order_item_clause) ( "," order_item_clause )*
limit_clause：
LIMIT (value | ALL) [ "," value ]
join_clause：
table_name INNER JOIN table_name ON join_condition | <br> table_name {LEFT | RIGHT} [OUTER] JOIN table_name ON join_condition
order_item_clause：
(expression | column name) [ ASC | DESC ]
UNION 语法：
<SELECT Query Statement> (UNION [ALL | DISTINCT] <SELECT Query Statement>)+
MySQL 字符串函数
Zoho Analytics 支持的 MySQL 内置字符串函数。
ASCII(string_arg)：
目的：
返回给定自变量的第一个字符的 ASCII 值。
示例：
Select ascii('ant’) 返回 '97’
注：
- 如果自变量为空，那么返回 '0’。
- 字符串的第一个字符可为任意字母、数字、符号或特殊字符。
BIN(numeric_arg)：
目的：
返回给定自变量的二进制值。
示例：
Select BIN('40’) 返回 '101000’
注：
- 如果自变量为 null，那么返回 null。
- 如果自变量为任何非数字字符，那么返回 0。
BIT_LENGTH(string_arg)：
目的：
返回字符串自变量的长度值（以位数计）。
示例：
Select BIT_LENGTH('AA’) 返回 '16’
注：
- 此自变量可包含任意数字、字母或特殊字符。
- 如果自变量为 null，那么返回 0。
CHAR(numeric_arg1, numeric_arg2, numeric_arg3,….)：
目的：
返回根据自变量中指定的 ASCII 代码的代码值构造的字符串。
示例：
Select CHAR (97.4,97.5) 返回 'ab’
Select CHAR ('97’,'X’,'98’) 返回 'a b’ // 对自变量中的每个非数字字符返回空格。
注：
- 如果自变量为 null，那么返回 null。
- 如果给定 ASCII 为小数，那么它返回最接近的整数值。
- 如果给定 ASCII 为小数，但以字符串形式给定，那么小数点之后的数字被忽略，仅返回小数点之前的数字的代码值。
CHAR_LENGTH(string_arg)：
目的：
返回自变量中的字符数。
示例：
Select CHAR_LENGTH('aa1’) 返回 '3’
注：
- 此自变量可包含任意数字、字母或特殊字符。
- 如果自变量为 null，那么返回 0。
- 多字节字符可计为单个字符。
CHARACTER_LENGTH(string_arg)：
目的：
返回自变量中的字符数。
示例：
Select CHARACTER_LENGTH('aa1’) 返回 '3’
注：
- 此自变量可包含任意数字、字母或特殊字符。
- 如果自变量为 null，那么返回 0。
- 多字节字符可计为单个字符。
CONCAT(string_arg1, string_arg2, string_arg3,…)：
目的：
返回自变量的并置字符串。
示例：
Select CONCAT('red’,'rose’) 返回 ’redrose’
注：
- 这些自变量可包含任意数字、字母或特殊字符。
- 如果所有自变量为 null，那么返回 null。
- 如果至少一个自变量不为 null 并且余下自变量为 null，那么返回非空自变量字符串。
CONCAT_WS(char_arg, string_arg1, string_arg2,…)：
目的：
返回自变量的并置字符串，第一个自变量充当并置字符串之间的分隔符。
示例：
Select CONCAT_WS (’,’,'red’,'rose’,'is’,'beautiful’) 返回 'red,rose,is,beautiful’
注：
- 这些自变量可包含任意数字、字母或特殊字符。
- 如果所有自变量为 null，那么返回 null。
- 分隔符可以是任意符号、字母、字符串或数字。
- 如果第一个自变量为 null，那么返回余下自变量的并置字符串。
- 如果至少一个自变量不为 null 并且余下自变量为 null，那么返回分隔符与其自身 (n-1) 次的并置，n 是自变量的数目。
ELT(numeric_arg, string_arg1, string_arg2,…)：
目的：
第一个自变量的值给出要从余下自变量返回的自变量的计数。
示例：
Select ELT ('2’,'red’,'rose’,'is’,'beautiful’) 返回 'rose’
注：
- 要返回的自变量的计数从第二个自变量开始计算。
- 如果第一个自变量为 null 或自变量数目小于计数，那么返回 null。
- 如果第一个自变量是非数字字符，那么返回 null。
FIELD(string_arg, string_arg1, string_arg2,…)：
目的：
使用所有其他自变量检查第一个自变量字符串，并返回找到第一个匹配项的自变量的位置。
示例：
Select FIELD ('as’,'has’,'as’,'have’) 返回 '2’
注：
- 自变量的位置从第二个自变量开始计算。
- 如果第一个自变量或余下自变量为 null，那么返回 '0’。
- 如果找不到匹配，那么返回 '0’。
FIND_IN_SET(string_arg1, string(element1,element2,…))：
目的：
使用第二个自变量检查第一个自变量字符串，第二个自变量是用逗号分隔的一组字符串，并返回集合中第一个匹配项的位置。
示例：
Select FIND_IN_SET ('10’,'2,5,8,10’) 返回 '4’
注：
- 如果第一个或第二个自变量为 null，那么返回 '0’。
- 如果第一个和第二个自变量都为 null，那么返回 'null’。
FORMAT(numeric_arg,numeric_arg)：
目的：
将第一个自变量中给出的数字舍入为第二个自变量中给出的小数位数。
示例：
SELECT FORMAT (1.0001111,5) 返回 '1.00011’
注：
- 如果第二个自变量为 0，那么返回的数字中没有小数值或小数点。
- 如果该数字没有小数，那么系统会在小数点后的数字后附加零。
HEX(string_arg)：
目的：
返回对应给定字符串的每个字符的相应十六进制数。
示例：
Select HEX('255’) 返回 '323535’
注：
- 如果给定自变量为 null，那么返回 null。
- 如果给定自变量以数字形式给出，那么返回该数字的十六进制数。
INSTR(string_arg, string_arg)：
目的：
返回第二个字符串自变量在第一个自变量中的第一个匹配项的位置。
示例：
Select INSTR ('impossible’,'possible’) 返回 '3’
注：
- 如果两个自变量为 null，那么返回 '1'。
- 如果只有第二个自变量为 null，那么返回 '1'。
- 如果只有第一个自变量为 null，那么返回 '0'。
- 如果第二个自变量与第一个字符串不匹配，那么返回 '0'。
LEFT(string_arg, numeric_arg)：
目的：
返回第一个自变量字符串中按第二个自变量中传递的字符数计算的字符。
示例：
Select LEFT ('select’,'3’) 返回 'sel’
注：
- 如果第二个自变量中为 null、'0’或传递任意非数字字符，那么返回 null。
- 如果第二个自变量的值超出第一个自变量字符串的字符数，那么完整返回第一个自变量字符串。
LENGTH(string_arg)：
目的：
返回字符串中的总字节数。多字节字符按多个字节计数。
示例：
Select LENGTH ('advent123!$’) 返回 '11’
注：
- 如果自变量为 null，那么返回 0。
LOCATE(string_arg)：
目的：
返回第一个字符串自变量在第二个字符串自变量中的位置。
示例：
Select LOCATE ('net’,'adventnet’) 返回 '7’
注：
- 如果第一个自变量不在第二个自变量中，那么返回 0。
- 如果第二个自变量为 null，那么返回 0。
- 如果第一个自变量为 null，那么返回 1。
- 如果两个自变量都为 null，那么返回 1。
LPAD(string_arg, numeric_arg, string_arg)：
目的：
第三个自变量将追加在第一个自变量的左侧，直到达到第二个自变量中给出的长度。
示例：
Select LPAD ('brother’,'9’,'hello’) 返回 'hebrother’
注：
- 如果结果字符串的总长度超过要达到的长度，那么在达到所需长度时第三个字符串自变量被截断。
- 如果第三个自变量为 null，那么返回 null。
- 如果第二个自变量为 0 或 null，那么返回 null。
- 如果第一个自变量的长度超出给定计数，那么第一个自变量截断至所需结果长度。
- 如果结果字符串的总长度小于要达到的长度，那么第三个字符串自变量将重复直到达到所需长度。
LTRIM(string_arg)：
目的：
返回自变量，其字符串之前的空格被移除。
示例：
Select LTRIM (’ ab cd’) 返回 'ab cd’
注：
- 字符之间的空格不受影响。
MAKE_SET(numeric_arg, string_arg1, string_arg2,…)：
目的：
针对第一个自变量中的给定数字，返回余下自变量中的对应自变量“集合”。
示例：
Select MAKE_SET (3,'ab’,'cd’,'ef’) 返回 'ab,cd’
注：
- 如果第一个自变量为 null 或 0，那么返回 null。
ORD(string_arg)：
目的：
如果字符串自变量的第一个字符为多字节字符，那么返回根据以下公式计算出来的代码。
1st byte code + (2nd byte code * 256) + (3rd byte code * 256 * 256) + …
REPEAT(string_arg, numeric_arg)：
目的：
返回按第二个自变量中给出的次数重复的第一个字符串自变量。
示例：
Select Repeat ('AA’,5) 返回 'AAAAAAAAAA’
注：
- 如果第一个自变量和第二个自变量中的一个或全部为 null，那么返回 null。
REPLACE(string_arg, string_arg, string_arg)：
目的：
在第一个字符串中，将第二个自变量中给定的字符串替换为第三个自变量中给出的字符串。
示例：
select replace('tention’,'ten’,'celebra’) 返回 'celebration’
注：
- 如果第二个自变量为 null，那么返回第一个自变量字符串。
- 如果第三个自变量为 null，那么返回第一个自变量字符串并从中移除第二个自变量字符串。
- 如果第二个和第三个自变量为 null，那么返回第一个自变量字符串。
REVERSE(string_arg)：
目的：
按字符反向顺序返回字符串自变量。
示例：
select reverse ('main’) 返回 'niam’
注：
- 如果自变量为 null，那么返回 null。
RIGHT(string_arg, numeric arg)：
目的：
按照第二个自变量中传递的计数，返回从第一个自变量中从右端计算的字符。
示例：
select RIGHT ('adventnet’,3) 返回 'net’
注：
- 如果第一个自变量和第二个自变量中的一个或全部为 null，那么返回 null。
RPAD(string_arg, numeric arg, string_arg)：
目的：
第三个自变量将追加在第一个自变量的右侧，直到达到第二个自变量中给出的长度。
示例：
select RPAD ('abcdef’,10,'ghijkl’) 返回 'abcdefghij’
注：
- 如果结果字符串的总长度超过要达到的长度，那么在达到所需长度时结果自变量字符串被截断。
- 如果第二个或三个自变量为 null，那么返回 null。
- 如果结果字符串的总长度小于要达到的长度，那么第三个字符串自变量将重复直到达到所需长度。
- 如果第一个自变量为 null，那么返回重复的第三个自变量。
RTRIM(string_args)：
目的：
返回自变量，其字符串之后的空格被移除。
示例：
Select rtrim ('abcd ’) 返回 'abcd’
注：
- 如果自变量为 null，那么返回 null。
SOUNDEX(string_arg)：
目的：
返回给定自变量的同音字符串。对于相同发音的字符串，同音字符串是相同的。
示例：
Select soundex ('bye’) 和 Select soundex ('boy’) 都返回 'b000’
SPACE(numeric_arg)：
目的：
返回等于自变量值的数目的空格字符。
示例：
Select space(6) 返回 ’ ’
注：
- 对于非数字或负值自变量，返回 null。
SUBSTRING(string_arg, numeric_arg)：
目的：
返回根据需要截断字符串自变量后构成的子串。
示例：
Select substring ('adventnet’,7) 返回 'net’
Select substring ('adventnet’ From 3) 返回 'ventnet’
Select substring ('adventnet’, 3,4 ) 返回 'vent’
Select substring ('adventnet’, -3) 返回 'net’
<> Select substring ('adventnet’, -7,4) 返回 'vent’
注：
- 数字自变量大于或小于字符串变量长度时，返回 null。
SUBSTRING_INDEX(string_arg, string_arg, numeric_arg)：
目的：
第二个自变量充当分隔符，第三个自变量为计数。在第一个自变量字符串中发现对应相应计数的分隔符的匹配时，截断字符串的余下部分。
示例：
select substring_index ('how.are.you’, ’.’, 2) 返回 'how.are’ // 对于正数，限制适用于分隔符的右侧。
select substring_index ('how.are.you’, ’.’, -2) 返回 'are.you’ // 对于负数，限制适用于分隔符的左侧。
注：
- 如果计数为 null、零或任意非数字字符，那么返回 null。
- 如果计数大于字符串中的分隔符数目，那么按原样返回给定字符串。
TRIM(string_arg)：
目的：
对于给定区分符，对字符串自变量进行相应裁剪。
示例：
Select TRIM (’ zoho ’) 返回 'zoho’ // 如果未给定区分符，那么字符串之前和之后的空格被裁剪。
Select TRIM (leading ’!’ from ’!!!!zoho!!!!’) 返回 'zoho!!!!’// 如果给定前导区分符，那么前缀部分被裁剪。
Select TRIM (trailing ’!’ from ’!!!!zoho!!!!’) 返回 ’!!!!zoho’ // 如果给定结尾区分符，那么后缀部分被裁剪。
UNHEX(string_arg)：
目的：
对于每对十六进制数，返回对应字符。
示例：
Select unhex('21’) 返回 ’!’
注：
- 如果自变量值并非十六进制数，那么返回 null。
UPPER(string_arg)：
目的：
以所有字符大写的形式返回自变量字符串。
示例：
select upper ('AdVeNt’) 返回 'ADVENT’
注：
- 数字和符号字符保持不变。
MySQL 算术函数
Zoho Analytics 支持的 MySQL 内置算术函数
ABS(numeric_arg)：
目的：
返回自变量中给出的数字的数值，而不考虑其符号。
示例：
Select ABS (-23) 返回 '23’
Select ABS (’-23’) 返回 '23.0’ // 如果数字以字符串形式传递，那么以小数格式返回数字。
Select ABS (’-23B0011’) 返回 '23.0’ // 如果在数字字符串中发现非数字字符，那么以小数格式返回该数字。
注：
- 对于非数字字符串自变量，返回 '0.0’。
- 对于空自变量，返回 '0.0’。
ACOS(numeric_arg)：
目的：
返回所传递自变量的反余弦值。该自变量值应在 -1 到 1 之间。
示例：
Select ACOS (0.5) 返回 '1.0471975511966’
Select ACOS ('0.5A@5’) 返回 '1.0471975511966’ // 如果在数字字符串中发现非数字字符，那么返回该数字的值。
注：
- 对于空自变量，返回 Acos(0) 的值，即 '1.5707963267949’。
- 对于非数字自变量，返回 Acos(0) 的值，即，'1.5707963267949’。
- 如果数字自变量值超出范围，那么返回 null。
ASIN(numeric_arg)：
目的：
返回所传递自变量的反正弦值。该自变量值应在 -1 到 1 之间。
示例：
Select ASIN (0.5) 返回 '0.5235987755983’
Select ASIN ('0.5A@5’) 返回 '0.5235987755983’ // 如果在数字字符串中发现非数字字符，那么返回该数字的值。
注：
- 对于空自变量，返回 '0.0’。
- 对于非数字自变量，返回 '0.0’。
- 如果数字自变量值超出范围，那么返回 null。
ATAN(numeric_arg)：
目的：
返回所传递自变量的反正切值。
示例：
Select ATAN (0.5) 返回 '0.46364760900081’
Select ATAN ('0.5A@5’) 返回 '0.46364760900081’ // 如果在数字字符串中发现非数字字符，那么返回该数字的值。
注：
- 对于空自变量，返回 '0.0’。
- 对于非数字自变量，返回 '0.0’。
- 负数的 ATAN 值等于其正数的 ATAN 值但加上负号。
ATAN2(numeric_arg)：
目的：
返回自变量中的字符数。
示例：
Select ATAN2 (2,4) 返回 '0.46364760900081’
Select ATAN2 ('0.5A’) 返回 '0.46364760900081’ // 如果在数字字符串中发现非数字字符，那么返回该数字的值。
注：
- 如果一个自变量为 null，另一个自变量为非数字，那么返回 '0.0’。
- 如果两个自变量都为 null 或零，那么返回 '0.0’。
- 如果第二个自变量为 '0’且第一个自变量为任意自然数，那么返回 '1.5707963267949’。
- 如果第二个自变量为 '0’且第一个自变量为任意非数字字符（或反过来），那么返回 '0.0’。
CEIL(numeric_arg)：
目的：
返回大于或等于该自变量值的最小整数。
示例：
Select CEIL (1.5) 返回 '2’
注：
- 如果自变量为 null 或任何非数字字符，那么返回 '0’。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 CEILING，该自变量字符的余下部分被忽略。
CEILING(numeric_arg)：
目的：
返回大于或等于该自变量值的最小整数。
示例：
Select CEILING (1.5) 返回 '2’
注：
- 如果自变量为 null 或任何非数字字符，那么返回 '0’。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 CEILING，该自变量字符的余下部分被忽略。
CONV(string_arg, numeric_arg1, numeric_arg2)：
目的：
将自变量数字字符串从给定基数转换为所需基数。第一个自变量是给定数字字符串，第二个自变量是该数字的原始基数，第三个自变量是该数字字符串要转换至的基数。
示例：
Select CONV ('F’,16,10) 返回 '15’
注：
- 如果任意自变量为 null，那么返回 null。
- 如果第二个或第三个自变量中给定的基数与该数字不兼容，那么返回 '0’。
- 基数的最大值为 36，最小值为 2。
COS(numeric_arg)：
目的：
返回所传递自变量的 COSINE 值。自变量的值应为弧度。
示例：
Select COS (45) 返回 '0.52532198881773’
注：
- 如果自变量为 null、零或任何非数字字符串，那么返回 '1.0’。
COT(numeric_arg)：
目的：
返回所传递自变量的 COTANGENT 值。
示例：
Select COT() 返回 “
注：
- 如果自变量为 null、零或任何非数字字符串，那么返回 null。
CRC32(numeric_arg)：
目的：
计算循环冗余校验后返回 32 位不带符号的输出。
示例：
Select CRC32 ('111’) 返回 '1298878781’
注：
- 如果自变量为 null，那么返回 0。
- 此自变量应为字符串。数字也会被视为字符串
DEGREES(numeric_arg)：
目的：
自变量的值将从弧度转换为度。
示例：
Select DEGREES (3.141593) 返回 '180’
注：
- 如果自变量为 null、零或任何非数字字符串，那么返回 null。
EXP(numeric_arg)：
目的：
返回变为给定数字自变量的幂的“e”的值。
示例：
Select EXP (6) 返回 '403.42879349274’
注：
- 如果该自变量中传递 null、零或任何非数字字符串，那么返回 '1.0’。
FLOOR(numeric_arg)：
目的：
返回小于或等于该自变量值的最大整数。
示例：
Select FLOOR (1.5) 返回 '1’
注：
- 如果自变量为 null 或任何非数字字符，那么返回 '0’。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 FLOOR，该自变量字符的余下部分被忽略。
FORMAT(numeric_arg, numeric_arg)：
目的：
将第一个自变量中给出的数字舍入为第二个自变量中给出的小数位数。
示例：
SELECT FORMAT (1.0001111,5) 返回 '1.00011’
注：
- 如果第二个自变量为 0，那么返回的数字中没有小数值或小数点。
- 如果该数字没有小数，那么系统会在小数点后的数字后附加零。
LN(numeric_arg)：
目的：
返回给定自变量的自然对数值。
示例：
Select LN('123’) 返回 '4.8121843553724’
注：
- 如果自变量为 null、负值或任何非数字字符串，那么返回 null。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 LN，该自变量字符的余下部分被忽略。
LOG(number1, number2)：
目的：
所执行功能与针对单个参数的 LN 相同。对于 2 个参数，第一个自变量是基数，第二个自变量是数字。返回该数字相对于基数的对数。
示例：
Select LOG(10,100) 返回 2.0
注：
- 仅接受数字。不接受以字符串形式给定的数字。
LOG2(numeric_arg)：
目的：
返回该数字相对于基数 2 的对数。
示例：
Select LOG2 (100) 返回 '6.6438561897747’
注：
- 如果自变量为 null、负值或任何非数字字符串，那么返回 null。
- 也接受以字符串形式给定的数字。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 LOG2，该自变量字符的余下部分被忽略。
LOG10(numeric_arg)：
目的：
返回该数字相对于基数 10 的对数。
示例：
Select LOG10 (100) 返回 '2.0’
注：
- 如果自变量为 null、负值或任何非数字字符串，那么返回 null。
- 也接受以字符串形式给定的数字。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 LOG10，该自变量字符的余下部分被忽略。
MOD(numeric_arg,numeric_arg)：
目的：
第一个自变量是被除数，第二个自变量是除数。返回除法的余数。
示例：
Select MOD (99,8) 返回 '3’
Select 99 mod 8 返回 '3’
Select 99 % 8 返回 '3’
注：
- 如果第一个自变量为 null，第二个自变量为任意数字，那么返回 '0.0’。
- 如果第二个自变量为 null，那么返回 null，不管第一个自变量为什么值都是如此。
OCT(numeric_arg)：
目的：
返回该自变量中给定的数字的八进制值。
示例：
Select OCT (12) 返回 '14’。
注：
- 如果自变量为 null 或任何非数字字符串，那么返回 '0’。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 OCT，该自变量字符的余下部分被忽略。
PI()：
目的：
返回 ¶ (pi) 的值，即 22 / 7。默认情况下，仅返回小数点后 6 位数字。
示例：
Select PI () 返回 '3.141593’
POW(numeric_arg, numeric_arg)：
目的：
第一个自变量是数字，第二个自变量是给定数字要变为的幂。返回变为所需幂的数字的值。
示例：
Select POW (3,4) 返回 '81.0’
注：
- 如果第二个自变量为零、null 或任何非数字字符串，那么不管第一个自变量的值和类型如何，都返回 '1.0’。
RADIANS(numeric_arg)：
目的：
自变量的值将从度转为弧度。
示例：
Select RADIANS ( 180) 返回 '3.1415926535898’
注：
- 对于任何非数字字符串自变量，返回 '0.0’。
- 如果在数字字符串自变量中发现非数字字符，那么返回该数字值的 RADIANS，该自变量字符的余下部分被忽略。
RAND(numeric_arg)：
目的：
对给定自变量返回 0 到 1 之间的随机值。
示例：
Select RAND (3) 返回 '0.90576975597606’
注：
- 如果自变量为 null、零或任何非数字字符串，那么返回 '0.15522042769494’。
ROUND(numeric_arg)：
目的：
返回给定小数的舍入值。
示例：
Select ROUND (23.248) 返回 '23’
Select ROUND (23.248, 1) 返回 '23.4’ // 将给定数字的小数位向上舍入为第二个自变量中给定的数字。
Select ROUND (23.248,-1) 返回 '20.0’
注：
- 如果第二个自变量为 null 或任何非数字字符串，那么给定数字将舍入（将第二个自变量的值视为零）。
SIGN(numeric_arg)：
目的：
根据自变量的符号，对于负数，返回 -1；对于零，返回 0；对于正数，返回 1。
示例：
Select SIGN (-200) 返回 ’-1’
Select SIGN (200) 返回 '1’
Select SIGN (-0) 返回 '0’ / 不管 0 之前的符号是什么，都返回 '0’。
注：
- 如果给定个自变量为非数字字符串，那么返回 0。
- 如果字符串包含数字且后跟字符，那么返回数字的符号。
SIN(numeric_arg)：
目的：
返回所传递自变量的 SINE 值。自变量的值应为弧度。
示例：
Select SIN ( 111) 返回 '0.86455144861061’
注：
- 对于空自变量和非数字自变量，返回 '0.0’。
- 在数字字符串中发现数字字符后，返回数字的 SIN 值。
SQRT(numeric_arg)：
目的：
返回给定数字的平方根值。
示例：
Select SQRT ('2’) 返回 '1.4142135623731’
注：
- 对于非数字字符串自变量，返回 null。
- 对于负数，返回 '0.0’。
- 对于后跟非数字字符串的数字，仅返回该数字的 SQRT。
TAN(numeric_arg)：
目的：
返回所传递自变量的 TAN 值。自变量的值应为弧度。
示例：
Select TAN ( '111’) 返回 '1.7203486651304’
注：
- 对于非数字字符串自变量或空自变量，返回 '0.0’。
- 对于负数，返回该自变量的绝对值的 TAN，并在开头加上负号。
TRUNCATE(string_arg)：
目的：
第一个自变量是给定小数，第二个自变量是决定要将给定数字的小数截断至的数字。返回被截断数字。
示例：
Select TRUNCATE (234.56789,2) 返回 '234.56’
Select TRUNCATE (234.56789,’-2’) 返回 '200.0’
注：
- 如果第二个自变量为 null、零或任何非数字字符串，那么截断所有小数。
MySQL 日期函数
Zoho Analytics 支持的 MySQL 内置日期时间函数。
ADDDATE(date_arg, numeric_arg)：
目的：
第一个自变量是日期值，第二个自变量是要添加至其的天数。返回新日期。
示例：
Select ADDDATE ( ’ 2008-08-03 ’ , 20 )
注：
- 要添加的时间间隔应为仅数字值，不应使用“INTERVAL 31 DAYS”格式。
ADDTIME(time_arg, time_arg)：
目的：
返回第一个自变量时间与第二个自变量时间相加的值。
示例：
Select ADDTIME ('12:30:15.55555555’, '01:00:44.444445’) 返回 '13:31:00.000000’
CONVERT_TZ(datetime_arg, time_arg, time_arg)：
目的：
将给定时间值转换为所需时间值，即，加上第三个自变量中给定的时间。结果时间值为 12 小时或 24 小时格式（取决于第二个自变量）。
示例：
Select CONVERT_TZ ( ’ 2008-11-06 03:00:00 ’ , ’ +09:00 ’ , ’ -5:30 ’ ) 返回 ’ 2008-11-05 12:30:00 ’
注：
- 为使结果使用 12 小时格式，第二个自变量应为 '12:00’。
- 为使结果使用 24 小时格式，第二个自变量应为 '00:00’。
CURDATE()：
目的：
以’yr:mth:dt ’ 格式返回当前时间。
示例：
Select CURDATE () 返回 '2008-11-06’
注：
- 根据函数的使用方式，结果返回为字符串或数字。
CURRENT_DATE()：
目的：
其功能与 CURDATE() 相同。
CURRENT_TIME()：
目的：
其功能与 CURTIME() 相同
CURTIME()：
目的：
以 ’ hr : min : sec ’ 格式返回系统的当前时间。
示例：
Select CURTIME() 返回 ’ 12：46 : 21 ’
Select CURTIME()+0 返回 ’ 124621.0 ’
注：
- 根据使用方式，该函数返回字符串或数字形式的结果。
DATE(date.time_arg)：
目的：
仅返回函数中给定的日期时间自变量的日期部分。
示例：
Select DATE ( ’ 2008-08-03 03:45:00 ’ ) 返回 ’ 2008-08-03 ’
注：
- 如果日期部分为非数字，那么返回 null。
- 即使时间部分为非数字，也返回日期部分。
DATEDIFF(date.time_arg, date.time_arg)：
目的：
返回自变量中给定的 2 个日期的间隔。相减时，仅采用两个自变量的日期时间值的日期部分。
示例：
Select DATEDIFF ( '1986-08-03 03:45:22’,'1986-08-23 18:45:43’) 返回 ’-20’
注：
- 时间部分不纳入计算范围。因此，即使时间部分为非数字，结果也不会有差别。
DAYNAME(date_arg)：
目的：
返回给定日期所在的当周日期。
示例：
Select DAYNAME ( ’ 2008-11-03 ’ ) 返回 ’ Monday ’
注：
- 如果给定日期的月份和年份错误，那么返回 null。
- 如果给定日期的值超过 31，那么返回 null。
- 即使给定日期相对于给定月份是错误日期，也返回当月日期。例如：2008 年 2 月 31 日返回 'Sunday’。
- 如果给定日期的值为 '0’，那么返回 '0’。
- 此函数的适用年份为 0 到 9999。
DAYOFMONTH(date_arg)：
目的：
返回自变量中的给定日期所在的当月日期。
示例：
Select DAYOFMONTH ( ’ 2008-11-03 ’ ) 返回 '3’
注：
- 如果给定日期的月份和年份错误，那么返回 null。
- 如果给定日期的日期值超过 31，那么返回 null。
- 即使给定日期相对于给定月份是错误日期，也返回当月日期。例如：2 月 31 日返回 31。
- 如果给定日期的值为 '0’，那么返回 '0’。
- 此函数的适用年份为 0 到 9999。
DAYOFYEAR(date_arg)：
目的：
返回给定日期的计数（从当年第一天开始计算）。
示例：
Select DAYOFYEAR ( ’ 2008-12-25 ’ ) 返回 '360’
注：
- 如果给定日期和月份为 '0’，那么返回 null。
- 结果在 1 到 366 之间。
DATE_ADD(date_arg, numeric_arg)：
目的：
执行所需算术运算后返回给定日期。Zoho Analytics 当前不支持 DATE_ADD。
DATE_SUB(date_arg, numeric_arg)：
目的：
执行所需算术运算后返回给定日期。Zoho Analytics 当前不支持 DATE_SUB。
EXTRACT(command from date.time_arg)：
目的：
对给定日期时间自变量执行减法后，返回日期时间值的所需部分。
示例：
Select EXTRACT ( HOUR_SECOND FROM ’ 2009-07-02 01:02:03 ’ ) 返回 ’ 10203 ’
FROM_DAYS(numeric_arg)：
目的：
天数从日期 01-01-01 开始计算。以计数形式采用此自变量值并显示对应日期。
示例：
Select FROM_DAYS ( 733714) 返回 ’ 2008-11-03 ’
注：
- 此计数从数字 366（它是日期 '0001-01-01’ 的计数）开始计算。
FROM_UNIXTIME(numerical_arg)：
目的：
对于给定自变量，返回内部时间戳记的值。
示例：
Select FROM_UNIXTIME (1225741235) 返回 ’ 2008-11-03 19:40:35 ’
注：
- 返回数字值或字符串值形式的结果（取决于给定输入自变量的类型）。
HOUR(time_arg)：
目的：
返回给定时间值中的小时数。时间以 'hr : min : sec’ 格式给出。
示例：
Select HOUR (’ 220:22:34 ’) 返回 '220’
注：
- 如果分钟或秒的值超过 '59’，那么返回 null。
- 如果以小数形式给定时间，那么返回 '0’。
LAST_DAY(date.time_arg)：
目的：
返回给定日期时间自变量的月份的最后日期。
示例：
Select LAST_DAY ( ’ 2004-02-31 01:02:03 ’ ) 返回 '29’
注：
- 如果给定日期、月份或年份错误或超出范围，那么返回 null。
LOCALTIMESTAMP()：
目的：
返回应用程序的时区的当前日期时间值。结果以 ’ yr : mth : dt hr : min : sec ’形式返回。
示例：
Select LOCALTIMESTAMP () 返回 '2008-08-23 12:59:41’
注：
- 根据查询中使用的函数，结果以数字或字符串形式返回。
MAKEDATE(numeric_arg, numeric_arg)：
目的：
此自变量包含年份及该日期在当年的计数。返回日期。
示例：
Select MAKEDATE ( 2008,215 ) 返回 ’ 2008-08-03 ’
注：
- 如果所传递计数 0，那么返回 null。
- 如果计数大于 366，那么该日期的年份也会发生变化。
MICROSECOND(date.time_arg)：
目的：
仅返回给定日期时间自变量值中的微秒部分。
示例：
Select MICROSECOND ( ’ 2008-11-04 17:16:50.123 ’ ) 返回 '123000’
注：
- 所返回的微秒位的默认位数为 '6’。
- 如果自变量中没有微秒位，那么返回 '0’。
MID(date_arg, numeric_arg)：
目的：
如果新年的给定日期位于上一年的最后一周中，那么返回上一年的最后一周的计数。
示例：
Select MID ( YEARWEEK ( ’ 2001-01-06 ’ ),5 ) 返回 ’ 53 ’
MINUTE(time_arg)：
目的：
返回给定时间值中的分钟数。时间以 'hr : min : sec’ 格式给出。
示例：
Select MINUTE (’ 220:22:34 ’) 返回 '22’
注：
- 如果分钟或秒的值超过 '59’，那么返回 null。
- 如果以小数形式给定时间，那么返回 '0’。
MONTH(date_arg)：
目的：
此函数返回给定日期的月份。
示例：
Select MONTH ( ’ 2008-08-03 ’ ) 返回 '8’
注：
- 如果给定日期包含 '00’ 月，那么返回 '0’。
- 年份应在 0 到 9999 之间。
NOW()：
目的：
返回应用程序的时区的当前日期时间值。结果以 ’ yr : mth : dt hr : min : sec ’形式返回。其功能与 LOCALTIMESTAMP() 相同。
示例：
Select NOW () 返回 '2008-08-23 12:59:41’
注：
- 根据查询中使用的函数，结果以数字或字符串形式返回。
PERIOD_ADD(numeric_arg, numeric_arg)：
目的：
此自变量包含日期以及要添加的月数。日期以时间格式（即，'yrmth’）传递。
示例：
Select PERIOD_ADD ( 198608,06 ) 返回 ’ 198702 ’
注：
- 所传递或返回的日期并非日期值，而是时间段值。
- 如果以常规格式（即，'yr:mth:dt’ 格式）传递日期，那么所返回结果值是错误的。
PERIOD_DIFF(numeric_arg, numeric_arg)：
目的：
在自变量中以时间段值的形式传递 2 个日期。返回 2 个值之间的月数。
示例：
Select PERIOD_DIFF ( 198608, 198606 ) 返回 ’-10’
注：
- 两个自变量都应为日期时间段格式。
- 如果第二个时间段的时间顺序在前，那么返回的值为正。
- 如果第二个时间段的时间顺序在后，那么返回的值为负。
QUARTER(date_arg)：
目的：
对于给定日期，返回该年的相应季度，如果月份为 1、2 或 3，那么返回 '1’；如果月份为 4、5 或 6，那么返回 2；如果月份为 7、8 或 9，那么返回 3；如果月份为 10、11 或 12，那么返回 4。
示例：
Select QUARTER ( ’ 2008-08-23 ’ ) 返回 '3’
注：
- 如果给定月份为 '0’，那么返回 '0’。
- 如果给定日期的年份、月份或日期超出范围，那么返回 null。
- 即使年份和/或日期为 '0’，也会返回对应月份的季度。
SEC_TO_TIME(numeric_arg)：
目的：
所传递自变量是当天的秒数。返回以小时、分钟和秒为单位的值。
示例：
Select SEC_TO_TIME ( 86399 ) 返回 ’ 23:59:59 ’
注：
- 对于 '86400’，'hr:min:sec’值重置为 '0’，并且周期再次开始。
- 如果在字符串中发现非数字字符，那么返回字符之前的数字的 SEC_TO_TIME。
- 根据给定自变量格式，结果以数字或字符串的形式给定。
SLEEP(numeric_arg)：
目的：
Zoho Analytics 当前不支持此函数。
STR_TO_DATE(numeric_arg, string_arg)：
目的：
返回从给定字符串转换而来的日期时间值。转换是在记录给定字符串的格式后进行的。格式是在第二个自变量中给定的。
示例：
Select STR_TO_DATE ( ’ 06/31/2004 ’, ’ %m/%d/%Y ’ ) 返回 ’ 2004-07-01 ’
注：
- 如果日期、月份或年份超出相应范围，那么返回 null。
- 根据字符串中的存在性，返回日期或时间值。
SUBDATE(date.time_arg, numeric_arg)：
目的：
返回从第一个自变量中传递的日期时间值减去第二个自变量中传递的天数后的日期时间值。
示例：
Select SUBDATE ( ’ 2008-02-19 12:00:00 ’, 31 ) 返回 ’ 2008 -01-19 12:00:00 ’
Select SUBDATE ( ’ 2008-02-19 ’, INTERVAL 31 DAY ) // Zoho Analytics 当前不支持此查询
注：
- 对此此函数有效的年份范围为 '200-9999’。如果年份低于 '200’，那么返回错误值，如果年份高于 '9999’，那么返回 null
- 如果月份是 1-12 以外的数字，那么返回 null。
- 如果日期是 1-31 以外的数字，那么返回 null。
SUBTIME(date.time_arg, time_arg)：
目的：
第一个自变量是日期时间值，第二个自变量是时间值。返回从第一个自变量减去第二个自变量后的值。
示例：
Select SUBTIME ( ’ 1986-08-03 18:45:00 ’ , ’ 03:45:00 ’ ) 返回 ’ 1986-08-03 15:00:00 ’
注：
- 如果第二个自变量中传递了日期值，那么返回 null。
- 对此此函数有效的年份范围为 '200-9999’。如果年份低于 '200’，那么返回错误值，如果年份高于 '9999’，那么返回 null。
- 如果月份是 1-12 以外的数字，那么返回 null。
- 如果日期是 1-31 以外的数字，那么返回 null。
SYSDATE()：
目的：
以 ’ yr : mth : dt hr : min : sec ’ 形式返回应用程序的时区的当前日期时间值。
示例：
Select SYSDATE () 返回 ’ 2008-11-05 05:41:16 ’
注：
- 根据查询中使用的函数，结果以数字或字符串形式返回。
TIME(date.time_arg)：
目的：
返回给定日期时间值自变量中的时间值。
示例：
Select TIME ( ’ 2008-11-05 17:34:45 ’ ) 返回 ’ 17:34:45 ’
注：
- 如果仅传递了日期值，那么该函数假定年份作为时间并返回。
- 如果日期值错误，那么返回 null。
TIMEDIFF(time_arg, time_arg)：
目的：
返回 2 个自变量中传递的 2 个时间值的间隔。
示例：
Select TIMEDIFF('20:08:05’,'20:07:34’) 返回 '00:00:31’
注：
- 第一个自变量应该大于第二个自变量，否则函数不起作用。
- 如果任一自变量中传递了日期值，那么返回 null。
- 如果两个自变量中同时传递了日期值，那么该函数不起作用。
TIMESTAMP(date.time_arg, time_arg)：
目的：
第一个自变量包含日期和时间值。第二个自变量仅应包含时间值。两个自变量会相加并返回所生成的日期时间值。
示例：
Select TIMESTAMP ( ’ 2008-11-05 19:00:00 ’ , ’ 06:00:00 ’ ) 返回 ’ 2008-11-06 01:00:00 ’
注：
- 如果仅传递第一个自变量，那么仅返回第一个自变量的日期值。
- 如果第二个自变量包含日期值，那么返回 null。
TIMESTAMPADD()：
目的：
Zoho Analytics 当前不支持此函数。
TIMESTAMPDIFF()：
目的：
Zoho Analytics 当前不支持此函数。
TIME_FORMAT(time_arg, string_arg)：
目的：
第一个自变量是时间，第二个自变量是包含格式区分符的格式字符串。返回带格式的值。
示例：
Select TIME_FORMAT ( ’ 19:30:41.32 ’ , ’ %k %l %i %s %f ’ ) 返回 ’ 19 7 30 41 320000 ’
注：
- 格式字符串只能包含时间格式区分符。
- 即使传递单个非时间区分符，也仅返回 null 值。
TIME_TO_SEC(time_arg)：
目的：
对于所传递时间值，在将分钟和小时转换为秒后返回总秒数。
示例：
Select TIME_TO_SEC ( ’ 01:00:00 ’ ) 返回 ’ 3600 ’
TO_DAYS(date_arg)：
目的：
将所传递日期自变量转换为自日期 '0001-01-01’ 开始计算的总天数
示例：
Select TO_DAYS ( ’ 2008-11-07 ’ ) 返回 ’ 733718 ’
注：
- 对此此函数有效的年份范围为 '200-9999’。如果年份低于 '200’，那么返回错误值，如果年份高于 '9999’，那么返回 null。
- 如果月份是 1-12 以外的数字，那么返回 null。
- 如果日期是 1-31 以外的数字，那么返回 null。
UNIX_TIMESTAMP(date.time_arg)：
目的：
返回自日期 ’ 1970-01-01 00:00:00 ’ 开始计算的已完成秒数
示例：
Select UNIX_TIMESTAMP ( ’ 1970-01-01 00:30:00 ’ ) 返回 ’ 1800 ’
注：
- 如果所传递日期早于日期 ’ 1970-01-01 00:00:00 ’，那么返回 '0’。
UTC_DATE()：
目的：
返回当前 UTC 日期。
示例：
Select UTC_TIMESTAMP () 返回 ’ 2008-11-06 05:40:58 ’
注：
- 根据所使用函数的格式，以数字或字符串值形式返回当前日期时间值。
UTC_TIMESTAMP()：
目的：
返回当前 UTC 日期时间值。
示例：
Select UTC_TIMESTAMP () 返回 ’ 2008-11-06 05:40:58 ’
注：
- 根据所使用函数的格式，以数字或字符串值形式返回当前日期时间值。
WEEK(date_arg)：
目的：
返回给定日期所在的年份的周。
示例：
Select WEEK(’ 2008-01-14 ’) 返回 '2’
注：
- 默认情况下，假定一周从周日开始。
- 如果希望一周从周一开始，那么应在第二个自变量中传递 MODE。
WEEKDAY(date_arg)：
目的：
返回给定日期所在的当周日期。如果为周一，那么返回 '0’，如果为周二，那么返回 '1’，……如果为周日，那么返回 '6’。
示例：
Select WEEKDAY ( ’ 2008-11-06 ’ ) 返回 '3’，因为该日期为周四。
注：
- 给定自变量可以是日期时间值或仅为日期值。
WEEKOFYEAR(date_arg)：
目的：
返回给定日期所在的年份的周。
示例：
Select WEEKOFYEAR ( ’ 2008-01-14 ’ ) 返回 '2’
注：
- 与 WEEK() 不同，在此函数中，不能使用第二个自变量。
YEAR(date_arg)：
目的：
此函数返回给定日期的年份。
示例：
Select YEAR ( ’ 2008-11-22 ’ ) 返回 ’ 2008 ’
注：
- 年份应在 0 到 9999 之间。
- 如果给定日期、月份或年份错误，那么返回 null。
YEARWEEK(date_arg)：
目的：
从日期 '0000-01-01’ 开始第一周的计数，返回给定日期所在的周。
示例：
Select YEARWEEK ( ’ 2000-01-02 ’ ) 返回 ’ 200001 ’
注：
- 如果月份是 1-12 以外的数字，那么返回 null。
- 如果日期是 1-31 以外的数字，那么返回 null。
- 如果年份是 9999 以上的数字，那么返回 null。
MySQL 汇总函数
Zoho Analytics 支持的 MySQL 内置汇总函数。
AVG(numeric_arg)：
目的：
返回给定项的值的平均值。
示例：
Select AVG (col1) from "tab5” 返回 '3’ // 此处 'tab5’ 是表名，'col1’ 是列名。
注：
- 如果该列未包含任何值，那么返回 null。
- 如果值中出现非数字字符，那么返回 '0.0’。
BIT_AND(numeric_arg)：
目的：
针对给定表的值执行按位进行的 AND 计算并返回结果。
示例：
SELECT BIT_AND (numCol) from “ allTypeTest ” 返回 '33’ // 返回工作空间 'allTypeTest’ 中的 'numcol’ 行的值的 Bitwise_AND 计算结果。
注：
- 如果该列未包含任何值，那么返回 null。
- 如果值中出现非数字字符，那么返回 '0’。
BIT_OR(numeric_arg)：
目的：
针对给定表的值执行按位进行的 OR 计算并返回结果。
示例：
SELECT BIT_OR (numCol) from “ allTypeTest ” 返回 '127’ // 返回工作空间 'allTypeTest’ 中的 'numcol’ 行的值的 Bitwise_OR 计算结果。
注：
- 如果该列未包含任何值，那么返回 null。
- 如果值中出现非数字字符，那么返回 '0’。
BIT_XOR(numeric_arg)：
目的：
针对给定表的值执行按位进行的 XOR 计算并返回结果。
示例：
SELECT BIT_XOR ( numCol ) from “ allTypeTest ” 返回 '121’ // 返回工作空间 'allTypeTest’ 中的 'numcol’ 行的值的 Bitwise_XOR 计算结果。
Select ATAN ('0.5A@5’) 返回 '0.46364760900081’ // 如果在数字字符串中发现非数字字符，那么返回该数字的值。
注：
- 如果该列未包含任何值，那么返回 null。
- 如果值中出现非数字字符，那么返回 '0’。
COUNT(numeric_arg)：
目的：
对给定表中的行进行计数。
示例：
Select COUNT (numCol) from “ allTypeTest ” 返回 '6’ // 因为工作空间 'allTypeTest’ 的 'numcol’ 列包含 6 行。
注：
- 如果该列未包含任何值，那么返回 '0’。
- 这些值可为数字和字符串。
GROUP_CONCAT(numeric_arg)：
目的：
将给定表中的字符串并置。
示例：
Select GROUP_CONCAT ( plainCol ) from “allTypeTest” 返回 'Hello,Hlo,Hello,Hlo,Hello,Hlo’
Select GROUP_CONCAT ( DISTINCT plainCol ) from “allTypeTest” 返回 'Hello,Hlo’ // 不重复输出字符串。
注：
- 如果该列未包含任何值，那么返回 null。
MAX(string_arg, numeric_arg1, numeric_arg2)：
目的：
对给定列中的值进行相互比较，并返回最大值。返回数字和字符串的最大值。
示例：
Select MAX (col3 ) from “tab2” 返回 'sat’
注：
- 如果该列未包含任何值，那么返回 null。
MIN(numeric_arg)：
目的：
对给定列中的值进行相互比较，并返回最小值。返回数字和字符串的最小值。
示例：
Select MIN (col3 ) from “tab2” 返回 'chk’
注：
- 如果该列未包含任何值，那么返回 null。
STD(number1, number2)：
目的：
计算并返回给定表的数值的标准偏差。
示例：
Select STD ( col2 ) from “ tab6 ” 返回 '8.0554’
注：
- 如果该列未包含任何值，那么返回 null。
- 如果该列仅包含非数字字符值，那么返回 '0.0’。
SUM(numeric_arg)：
目的：
计算并返回给定表的值的总和。
示例：
Select SUM ( col2 ) from “ tab6 ” 返回 '32.0’
注：
- 如果该列未包含任何值，那么返回 null。
- 如果该列仅包含非数字字符值，那么返回 '0.0’。
VARIANCE(numeric_arg)：
目的：
计算并返回给定表的值的方差。返回到该数字相对于基数 10 的对数。
示例：
Select VARIANCE ( col2 ) from “ tab6 ” 返回 '64.8889’
注：
- 如果自变量为 null、负值或任何非数字字符串，那么返回 null。
- 如果该列仅包含非数字字符值，那么返回 '0.0’。
API 使用限制和定价
Zoho Analytics API 使用情况是根据 API 调用的使用单元数和频率计算的。本节描述 API 单元数和频率计算。允许的 API 单元数由每个
为确保实现卓越的资源利用率和服务质量，Zoho Analytics 根据 API 调用的使用单元数和调用频率控制 API 使用情况。本文档描述相关的详细信息。
API 单元
每个 Zoho Repots API 方法与一个所定义的单元数量相关联。应用程序使用的单元数是根据您的应用程序每天调用不同 API 方法的频率来计算的。
每个 Zoho Analytics
定价方案以及每天允许的 API 单元数：
| 方案 | 每天的 API 单元数 |
|---|---|
| 免费 | 1,000 个单元 |
| 基本 | 4,000 个单元 |
| 标准 | 10,000 个单元 |
| 高级版 | 30,000 个单元 |
| 企业版 | 100,000 个单元 |
例如，Zoho Analytics 标准方案中的用户帐户每天只能使用最多 10,000 个 API 单元。
针对每个 API 方法/操作计算的单元数
下表提供调用每个不同类型的 API 方法时使用的单元数。
| API 描述 | API 操作名称 | 单元数 |
|---|---|---|
| API 类型 - BULK | ||
| 使用 APPEND 选项导入 | 每 1000 行 10 个单元 | |
| 使用 TRUCATEADD 选项导入 | 每 1000 行 10 个单元 | |
| 使用 UPDATEADD 选项导入 | 每 1000 行 15 个单元 | |
| 以图像或 PDF 格式导出图表视图 | 每个请求 10 个单元 | |
| 以 PDF 格式导出任意视图 | 每 1000 行 5 个单元 | |
| 以任意格式导出统计图表 | 每个请求 15 个单元 | |
| 以 HTML 格式导出任意视图 | 每个请求 15 个单元 | |
| 所有其他导出操作 （未出现在以上 EXPORT 分类中） 示例： 1.以 CSV 格式导出表 2.以 JSON 格式导出透视图等等 |
每 1000 行 3 个单元 | |
| 复制不带数据的工作空间 | 每个请求 25 个单元 | |
| 复制带有数据的工作空间 | 每个请求 25 个单元 + 每 1000 行 1 个单元 | |
| API 类型 - DML | ||
| 添加单行 | 每个请求 0.1 个单元 | |
| 更新行 | 每个请求 0.3 个单元 | |
| 删除行 | 每个请求 0.1 个单元 | |
| API 类型 - METADATA | ||
| 获取工作空间元数据 | 每个请求 1 个单元 | |
| 获取视图名称 | 每个请求 0.1 个单元 | |
| 获取工作空间名称 | 每个请求 0.1 个单元 | |
| 获取视图信息 | 每个请求 0.1 个单元 | |
| 删除工作空间 | 每个请求 1 个单元 | |
| 获取视图 URL | 每个请求 1 个单元 | |
| 获取复制工作空间密钥，以在复制工作空间、复制报告等等之类的其他 API 中使用。 | 每个请求 1 个单元 | |
| 复制报告 | 每个请求 5 个单元 | |
| 复制公式 | 每个请求 2 个单元 | |
| 获取所有共享信息 | 每个请求 1 个单元 | |
| 向 Zoho Analytics 帐户添加用户 | 每个请求 0.1 个单元 | |
| 从 Zoho Analytics 帐户移除用户 | 每个请求 0.1 个单元 | |
| 在 Zoho Analytics 帐户中激活用户 | 每个请求 0.1 个单元 | |
| 在 Zoho Analytics 帐户中停用用户 | 每个请求 0.1 个单元 | |
| 对用户共享视图 | 每个请求 5 个单元 | |
| 移除用户的视图权限 | 每个请求 5 个单元 | |
| 对工作空间添加工作空间管理员 | 每个请求 5 个单元 | |
| 在工作空间中移除工作空间管理员 | 每个请求 5 个单元 | |
| 获取嵌入 URL | 每个请求 1 个单元 | |
| 在 Zoho Analytics 表中添加列 | 每个请求 15 个单元 | |
| 在 Zoho Analytics 表中删除列 | 每个请求 10 个单元 | |
| 在 Zoho Analytics 表中重命名列 | 每个请求 1 个单元 | |
| 在 Zoho Analytics 工作空间中创建表 | 每个请求 1 个单元 | |
| 在 Zoho Analytics 工作空间中重命名视图 | 每个请求 0.1 个单元 | |
| 在 Zoho Analytics 表中创建查找列 | 每个请求 1 个单元 | |
| 在 Zoho Analytics 表中移除查找列 | 每个请求 2 个单元 | |
| 获取 Zoho Analytics 帐户的方案信息 | 每个请求 0.1 个单元 | |
| 在 Zoho Analytics 帐户中检查工作空间 | 每个请求 0.1 个单元 | |
| 通过 Zoho Analytics 表生成报告 | 每个请求 1 个单元 | |
| 在 Zoho Analytics 帐户中获取用户列表 | 每个请求 1 个单元 | |
| 在 Zoho Analytics 表中隐藏列 | 每个请求 0.1 个单元 | |
| 在 Zoho Analytics 表中显示列 | 每个请求 0.1 个单元 | |
| 对白标域启用工作空间 | 每个请求 0.1 个单元 | |
| 对白标域禁用工作空间 | 每个请求 0.1 个单元 | |
| 对基于引用视图的视图生成报告 | 每个请求 1 个单元 |
例如，进行“IMPORT” API（导入 APPEND 类型）调用以导入 10,000 行，所使用单元数为：(10,000/1,000) * 10 个单元 = 使用 100 个单元。
Note:如果每天消耗的 API 总单元数超过所购方案的允许单元数，那么 Zoho Analytics 将发送错误响应，代码为 6043（或）6044。
API 频率
API 频率是指每分钟发出的 API 请求数。不同 API 类型具有不同频率限制。以下提供每个 API 类型的频率限制阈值。例如，在 1 分钟内，可针对 DML 类型 API 发送的最大请求数为 100。
每分钟的 API 频率
| API 类型 | 每分钟频率限制 |
|---|---|
| DML | 100 |
| BULK | 40 |
| METADATA | 60 |
| OVERALL * | 100 |
- 不管 API 类型 (DML / BULK / METADATA) 如何，1 分钟内最多允许发送 100 个请求。该分钟内发出的更多请求不会获得处理。
Note:如果每分钟触发的 API 请求数超过上述允许频率限制，那么 Zoho Analytics 将发送错误响应，代码为 6045。
API 单元附加项定价
如果 API 用量超出所购买 Zoho Analytics 方案的允许限制，那么该帐户的管理员可
| API 单元数/日 | 金额（每月） |
|---|---|
| 10,000 个单元/日 | $15 |
| 25,000 个单元/日 | $25 |
| 50,000 个单元/日 | $40 |
| 100,000 个单元/日 | $60 |
| 200,000 个单元/日 | $80 |