用户权限管理

注意：2.00.9 和 1.30.21 版本后，角色管理函数可以在数据节点执行，之前版本只允许在控制节点操作。

将用户本身也视为一个特殊的组，用户本身的权限就是这个组的权限。用户的最终权限是其所属的所有组的权限共同决定的结果。组的存在简化了对用户权限的管理，与此同时也不免出现权限冲突的情况，以下为权限确定规则：

• 若用户在至少一组中被赋予某项权限，并且在其他组中没有禁止该项权限，则用户拥有该项权限
• 若用户在至少一组中被禁止某项权限，即使在其他组中被赋予该项权限，此用户的该项权限依然被禁止

例 1：若用户只属于一个组，用户对某个权限的状态为 Deny，所在组对当前权限的状态为 Allow，则最终用户对该权限的状态为 Deny：

login("admin","123456")
createUser("user2","123456")
createGroup("group1",["user2"])
deny(`user2, DB_OWNER)//禁止 user2 拥有 DB_OWNER 权限
grant(`group1, DB_OWNER)//赋予 group1DB_OWNER 权限
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 没有 DB_OWNER 权限
=> <NoPrivilege>Not granted to create or delete databases

例 2：若用户只属于一个组，用户对某个权限的状态为 None，所在组对当前权限的状态为 Allow，则最终用户对该权限的状态为 Allow：

login("admin","123456")
revoke(`user2, DB_OWNER)//撤销禁止 user2 的 DB_OWNER 权限
grant(`group1, DB_OWNER)//赋予 group1DB_OWNER 权限
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 拥有 DB_OWNER 权限

例 3：若用户只属于一个组，用户对某个权限的状态为 None，所在组对当前权限的状态为 Deny，则最终用户对该权限的状态为 Deny：

login("admin","123456")
revoke(`user2, DB_OWNER)//撤销禁止 user2 的 DB_OWNER 权限
deny(`group1, DB_OWNER)//赋予 group1DB_OWNER 权限
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 没有 DB_OWNER 权限
=> <NoPrivilege>Not granted to create or delete databases

例 4：若用户属于多个组，某个组对某个权限的状态为 Deny，其他组对当前权限的状态为 Allow，则最终用户对该权限的状态为 Deny：

login("admin","123456")
createGroup("group2",["user2"])
createGroup("group3",["user2"])
deny(`group1, DB_OWNER)
grant(`group2, DB_OWNER)
grant(`group3, DB_OWNER)
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 没有 DB_OWNER 权限
=> <NoPrivilege>Not granted to create or delete databases

例 5：若用户属于多个组，某个组对某个权限的状态为 None，其他组对当前权限的状态为 Allow，则最终用户对该权限的状态为 Allow：

login("admin","123456")
revoke(`group1, DB_OWNER)
grant(`group2, DB_OWNER)
grant(`group3, DB_OWNER)
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 拥有 DB_OWNER 权限

例 6：若用户属于多个组，某个组对某个权限的状态为 None，其他组对当前权限的状态为 Deny，则最终用户对该权限的状态为 Deny：

login("admin","123456")
revoke(`group1, DB_OWNER)
deny(`group2, DB_OWNER)
deny(`group3, DB_OWNER)
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 没有 DB_OWNER 权限
=> <NoPrivilege>Not granted to create or delete databases

例 7：若用户所在的组被删除，则以用户本身被赋予的权限为准：

login("admin","123456")
createUser("user2","123456")
createGroup("group1",["user2"])
grant(`user2, DB_OWNER)//赋予 user2 DB_OWNER 权限
deny(`group1, DB_OWNER)//禁止 group1 DB_OWNER 权限
deleteGroup(`group1)//删除 group1
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 拥有 DB_OWNER 权限
----------------------------------------------------------------
login("admin","123456")
createGroup("group1",["user2"])
revoke(`user2, DB_OWNER)//回收 user2 DB_OWNER 权限
grant(`group1, DB_OWNER)//赋予 group1 DB_OWNER 权限
deleteGroup(`group1)//删除 group1
login("user2","123456")
database("dfs://test",VALUE,1..10)//user2 没有 DB_OWNER权限

权限作用的对象范围从大到小可以分为：全局 (*)，数据库，表。

以下为库表级权限确定规则：

• 先小范围赋予/撤销/禁止权限，再大范围操作权限，此时小范围权限失效，会被大范围的权限覆盖
• 先大范围 allow, 再小范围 deny，此时 deny 操作生效，allow 权限覆盖的除 deny 以外的范围依旧是 allow
• 先大范围 allow, 再小范围 revoke，此时 revoke 操作无效，allow 权限覆盖的范围依旧是 allow
• 先大范围 deny, 再小范围 revoke，此时 revoke 操作无效，deny 权限覆盖的范围依旧是 deny
• 先大范围 deny, 再小范围 grant，1.30.21 和 2.00.9 版本前 grant 可以生效，deny 权限覆盖的除 grant 以外的范围依旧是 deny，1.30.21 和 2.00.9 版本后不支持此操作
• 先大范围 revoke, 再小范围操作权限，此时小范围权限操作生效

例 1：对用户 user1 deny 表级的 TABLE_READ 权限，然后 grant 全局 TABLE_READ 权限，此时 user1 拥有所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user1","123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)

deny("user1", TABLE_READ, dbName+"/pt")
grant("user1", TABLE_READ, "*")

login("user1", "123456")
select * from loadTable(dbName, "pt")//user1 获得读 "dfs://test"的权限

例 2：对用户 user2 grant 表级的 TABLE_READ 权限，然后 deny 全局 TABLE_READ 权限，此时 user2 被禁止所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user2","123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)

grant("user2", TABLE_READ, dbName+"/pt")
deny("user2", TABLE_READ, "*")

login("user2", "123456")
select * from loadTable(dbName, "pt")//user2 被禁止读 "dfs://test"

例 3：对用户 user3 grant 表级的 TABLE_READ 权限，然后 revoke 全局 TABLE_READ 权限，此时 user3 被回收所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user3","123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)

grant("user3", TABLE_READ, dbName+"/pt")
revoke("user3", TABLE_READ, "*")
login("user3", "123456")
select * from loadTable(dbName, "pt")//user 被撤回读 "dfs://test" 的权限

例 4：先对用户 user1 grant 全局的 TABLE_READ 权限，然后 deny "dfs://test/pt" 表 TABLE_READ 权限，此时 user1 拥有除 "dfs://test/pt" 表外所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user1","123456")
dbName = "dfs://test"
t = table(1..10 as id , rand(100, 10) as val)
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)
grant("user1", TABLE_READ, "*")
deny("user1", TABLE_READ, dbName+"/pt")

login("user1", "123456")
select * from loadTable(dbName, "pt")//user1被禁止读"dfs://test/pt"

例 5：先对用户 user1 grant 全局的 TABLE_READ 权限，然后 revoke "dfs://test/pt" 表 TABLE_READ 权限，此时 user1 仍然拥有所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user1","123456")
dbName = "dfs://test"
t = table(1..10 as id , rand(100, 10) as val)
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)
grant("user1", TABLE_READ, "*")
revoke("user1", TABLE_READ, dbName+"/pt")

login("user1", "123456")
select * from loadTable(dbName, "pt")//user1 有读 "dfs://test/pt" 的权限

例 6：先对用户 user1 deny 全局的 TABLE_READ 权限，然后 revoke "dfs://test/pt" 表 TABLE_READ 权限，此时 user1 仍然被拒绝所有表的 TABLE_READ 权限：

login("admin", "123456")
createUser("user1","123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt.append!(t)

deny("user1", TABLE_READ, "*")
revoke("user1", TABLE_READ, dbName+"/pt")

getUserAccess("user1")//TABLE_READ 依旧是 deny

例 7：先对用户 user1 deny 全局的 TABLE_READ 权限，然后 grant "dfs://test/pt" 表 TABLE_READ 权限，1.30.21 和 2.00.9 版本前，此时 user1 被赋予读 "dfs://test/pt" 表的权限，被拒绝其他所有表的 TABLE_READ 权限，而新版本则在执行 grant 的时候抛出异常：

login("admin", "123456")
createUser("user1","123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id")
pt1=  db.createPartitionedTable(t, "pt1", "id")
pt.append!(t)
pt1.append!(t)

deny("user1", TABLE_READ, "*")
//新版本中执行grant报错 'Invalid grant: grant [dfs://test/pt] and [deny *] are in conflict'
grant("user1", TABLE_READ, dbName+"/pt")
login("user1", "123456")
select * from loadTable(dbName, "pt")//老版本有读 dbName+"/pt" 的权限
select * from loadTable(dbName, "pt1")//老版本没有读其他表的权限

1.30.21 和 2.00.9 版本前，如果某个用户对两张不同表分别 grant 和 deny 相同的表层面权限（TABLE_READ 或 TABLE_WRITE），升级到新版本后该用户会拥有除 deny 的表以外所有表的该权限。举例如下：

1.30.21 和 2.00.9 版本以前，使用 grant 命令赋予或使用 deny 命令禁用用户 'user1'不同表对象的 TABLE_READ 权限后，'user1' 将只有 "dfs://valuedb/pt1" 表的读权限：

login("admin","123456")
createUser("user1","123456")
grant("user1",TABLE_READ,"dfs://valuedb/pt1")
deny("user1",TABLE_READ,"dfs://valuedb/pt2")

升级到新版本后，user1 拥有 "dfs://valuedb" 库中除 pt2 以外所有表的读权限，等同于执行：

grant("user1",TABLE_READ,"dfs://valuedb/*")
deny("user1",TABLE_READ,"dfs://valuedb/pt2")

• DB_MANAGE：1.30.21 和 2.00.9 版本之前，可以创建以及删除数据库，可删除任何人所建数据库，包括具有 DB_OWNER 权限之用户所建数据库；1.30.21 和 2.00.9 版本之后不能创建数据库，只能删除数据库
• DB_OWNER：创建数据库并管理其创建的数据库，包括删除数据库、创建或删除数据表、增加或删除分区、可赋予、禁止或取消其他用户对自己创建的数据库的以下权限：TABLE_READ, TABLE_WRITE, TABLE_INSERT, TABLE_UPDATE, TABLE_DELETE, DBOBJ_CREATE, DBOBJ_DELETE, DB_READ, DB_WRITE, DB_INSERT, DB_UPDATE, DB_DELETE
• DBOBJ_CREATE：允许在数据库中建表
• DBOBJ_DELETE：允许在数据库中删除表
• DB_WRITE：允许写数据库所有表，包含表的增删改权限
• DB_INSERT：允许追加数据到某库所有表
• DB_UPDATE：允许更新某库所有表的数据
• DB_DELETE：允许删除某库所有表的数据
• DB_READ：允许读某库所有表

• TABLE_WRITE：允许增删改所有/指定数据表
• TABLE_READ：允许读取所有/指定数据表
• TABLE_INSERT：允许追加数据到指定表
• TABLE_UPDATE：允许更新指定表的数据
• TABLE_DELETE：允许删除指定表的数据

• VIEW_OWNER：普通用户（组）创建视图的权限。只有管理员才能 grant/deny/revoke 这个权限，此为 2.00.10.4/1.30.22.4 版本新增功能。普通用户（组）被赋予该权限后，可以进行以下操作：
  • 可以创建视图（addFunctionView），且在创建视图后自动拥有该视图的 VIEW_EXEC 权限
  • drop 自己创建的视图（dropFunctionView）
  • 为其它用户 grant/deny/revoke 自己所创建视图的 VIEW_EXEC 权限
  • 通过 getFunctionViews 查看自己创建的所有视图
• VIEW_EXEC：视图执行权限
• SCRIPT_EXEC：脚本执行权限
• TEST_EXEC：测试脚本执行权限
• QUERY_RESULT_MEM_LIMIT：限制用户的查询内存大小
• TASK_GROUP_MEM_LIMI：限制用户发送的批量子查询占用的内存大小

1. 1.30.21 和 2.00.9 版本前创建的用户，如果只拥有 DB_MANAGE 权限而没有 DB_OWNER 权限，升级到新版本就无法创建库，需要重新赋予 DB_OWNER 权限。
2. 1.30.21 和 2.00.9 版本前创建的用户，如果被赋予 TABLE_WRITE 权限，升级到新版本后将同时拥有 TABLE_INSERT, TABLE_UPDATE, TABLE_DELETE 权限。
3. 1.30.21 和 2.00.9 版本起，accessType=DB_OWNER 时 grant / deny / revoke 命令中的 objs 若作用于库必须以"*"结尾，表示指定某个 dbName 的前缀范围：

login("admin", "123456")
createUser("user1","123456")
grant("user1", DB_OWNER,"*")//用户拥有所有数据库的 DB_OWNER 权限
grant("user1", DB_OWNER,"dfs://test0*")//用户拥有以 "dfs://test0" 为前缀的数据库 DB_OWNER 权限

1. 1.30.21 和 2.00.9 版本起，accessType=DB_MANAGE 时，使用 grant / deny / revoke 命令需确保 objs 中指定的数据库已存在，否则将报错：

login("admin", "123456")
createUser("user1","123456")
grant("user1", DB_MANAGE,"dfs://test0") => The database [dfs://test0]  does not exist
grant("user1", DB_MANAGE, ["dfs://db1","dfs://db2"]) => The database [dfs://db1]  does not exist

表级别的权限在指定表或用户删除的时候回收，库级别的权限在指定库或用户删除的时候回收，DB_OWNER 权限只在用户和该用户下所有库都删除的时候回收。

当权限操作的访问对象为共享内存表、流数据引擎时，权限不会因 server 重启或共享内存表、流数据引擎的删除而回收。当再次创建同名共享内存表、流数据引擎并对其进行访问控制时，对用户的权限操作依然生效。

例 1： "user1" 拥有 "dfs://valuedb/pt" 表的 TABLE_READ 权限，删除 "dfs://valuedb/pt" 表后重新创建，user1 用户的 TABLE_READ 权限被回收：

login("admin", "123456")
dbName = "dfs://valuedb"
t = table(1..10 as id , rand(100, 10) as val)
if(existsDatabase(dbName)){
        dropDatabase(dbName)
} 
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id").append!(t)

createUser("user1","123456")
grant("user1", TABLE_READ,"dfs://valuedb/pt")
login("user1", "123456")
select * from loadTable( "dfs://valuedb",`pt)//此时user1 拥有"dfs://valuedb/pt"表的TABLE_READ权限
login("admin", "123456")
dropTable(db,`pt)
pt=  db.createPartitionedTable(t, "pt", "id").append!(t)
login("user1", "123456")
select * from loadTable( "dfs://valuedb",`pt)//user1用户的TABLE_READ权限被回收

例 2： "user1" 拥有 "dfs://valuedb" 库的 DB_MANAGE 权限，删除 "dfs://valuedb" 库后重新创建，user1 用户的 DB_MANAGE 权限被回收：

login("admin", "123456")
dbName = "dfs://valuedb"
t = table(1..10 as id , rand(100, 10) as val)
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id").append!(t)

createUser("user1","123456")
grant("user1", DB_MANAGE,"dfs://valuedb")
getUserAccess("user1")

此时 user1 拥有 "dfs://valuedb" 库的 DB_MANAGE 权限。

login("admin", "123456")
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
db=database(dbName, VALUE, 1..10)
pt=  db.createPartitionedTable(t, "pt", "id").append!(t)
getUserAccess("user1")

此时 user1 用户的 DB_MANAGE 权限被回收。

例 3： "u1" 用户拥有流数据表 "trades"、"output1" 和流引擎 "agg1" 的读写权限：

login(`admin, `123456)
createUser(`u1, "111111");
enableTableShareAndPersistence(streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]),`trades)
share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as  output1
agg1 = createTimeSeriesEngine(name="agg1", windowSize=600, step=600, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)
grant("u1", TABLE_READ, "agg1")
grant("u1", TABLE_WRITE, "agg1")
grant("u1", TABLE_READ, "trades")
grant("u1", TABLE_WRITE, "trades")
grant("u1", TABLE_READ, "output1")
grant("u1", TABLE_WRITE, "output1")
getUserAccess(`u1)

重启或删除并创建同名流数据表 "trades"、"output1" 和流引擎 "agg1"，此时三个对象都没有访问控制，任何用户可以对其进行读写：

login(`admin, `123456)
enableTableShareAndPersistence(streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]),`trades)
share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as  output1
agg1 = createTimeSeriesEngine(name="agg1", windowSize=600, step=600, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)

增加访问控制：

addAccessControl(`trades)
addAccessControl(output1)
addAccessControl(agg1)

此时只有用户 "u1" 和三个对象的创建者 "admin" 可以访问对象：

login(`u1, "111111")
insert into agg1 values(2018.10.08T01:01:01.785,`A,10) 
insert into output1 values(2018.10.08T01:01:01.785,`A,10) 
insert into trades values(2018.10.08T01:01:01.785,`A,10) 

其他用户被拒绝访问：

login(`u2, "111111")
insert into agg1 values(2018.10.08T01:01:01.785,`A,10)=> No access to table [agg1]'
insert into output1 values(2018.10.08T01:01:01.785,`A,10) => No access to table [output1]'
insert into trades values(2018.10.08T01:01:01.785,`A,10) => No access to table [trades]'

分布式表 DDL 和 DML 操作所需权限如下表所示：

注意：在执行 addColumn、dropColumns!、renameColumns、replaceColumns、setColumnComment、rename!、renameTable 函数时，若用户所操作的表对象为其他用户所创建，需要给当前用户赋予表对象的 TABLE_READ 权限。

例如：

在用户 user1 创建的数据库中赋予 user2 DBOBJ_CREATE 权限并创建表 pt1:

login("admin", "123456")
createUser("user1","123456",,true)
createUser("user2","123456",,true)
grant(`user1, DB_OWNER,"dfs://test*")

login("user1", "123456")
dbName = "dfs://test"
if(existsDatabase(dbName)){
        dropDatabase(dbName)
}
t = table(1..10 as id , rand(100, 10) as val)
db=database(dbName, VALUE, 1..10)
grant(`user2, DBOBJ_CREATE ,"dfs://test")
login("user2", "123456")
pt1=  db.createPartitionedTable(t, "pt1",`id).append!(t)

此时若 user1 想要 rename 表 pt1 某一列，会报错：

login("user1", "123456")
rename!(pt1,`val,`val1)// <NoPrivilege>Not granted to read table dfs://test/pt1'

需要赋予 user1 对 pt1 表的读权限：

login("admin", "123456")
grant(`user1, TABLE_READ,"dfs://test/pt1")

此时 rename 成功：

login("user1", "123456")
rename!(pt1,`val,`val1)
schema(loadTable(dbName,`pt1)).colDefs
------------------------------------------
name typeString typeInt extra comment
---- ---------- ------- ----- -------
id   INT        4                    
val1 INT        4                          

可见性函数所需权限如下表所示：

注意：在新版本中，仅拥有 VIEW_EXEC 权限的用户无法获取上述函数结果。

在分布式数据库中，可以通过 grant / deny / revoke 命令设置用户或者组的权限。在库级权限类别及表级权限类别节中的所有权限，可作为上述三个命令的 accessType 参数值。

其中，TABLE_READ，TABLE_WRITE，TABLE_INSERT，TABLE_UPDATE，TABLE_DELETE 权限作用范围为全局或表级。DBOBJ_CREATE，DBOBJ_DELETE，DB_READ，DB_WRITE，DB_INSERT，DB_UPDATE，DB_DELETE，DB_MANAGE，DB_OWNER 权限作用范围为全局或库级。

例 1：赋予用户 "user1" 全局的 TABLE_READ 权限：

 grant(`user1, TABLE_READ, "*")

例 2：赋予 "user1" 用户 "dfs://valuedb" 库下 pt 表的 TABLE_READ 权限：

 grant(`user1, TABLE_READ,"dfs://valuedb/pt")

例 3：赋予 "user1" 用户 "dfs://valuedb" 库的 DBOBJ_CREATE 权限：

 grant(`user1, DBOBJ_CREATE,"dfs://valuedb")

例 4：授权某个用户对某数据库中所有表的读写权限（1.30.21 和 2.00.9 版本新增功能）：

login("admin","123456")
createUser("user1","123456")
grant("user1",DB_READ,"dfs://valuedb")
grant("user1",DB_WRITE,"dfs://valuedb")

此时 user1 拥有 "dfs://valuedb" 库中所有增删改查权限。

例 5：限制用户创建并管理以 "dfs://db0" 为前缀的数据库（1.30.21 和 2.00.9 版本新增功能）：

login("admin","123456")
createUser("AlexSmith","123456")
grant("AlexSmith", DB_OWNER, "dfs://db0*")

此时若用户 "AlexSmith" 创建以 "dfs://db1" 命名的数据库，会被拒绝。

例 6：赋予一个组中所有组员读某张表的权限，但只有部分组员有写权限：

login("admin","123456")
createUser("user1","123456")
createUser("user2","123456")
createUser("user3","123456")
createGroup("group1",["user1","user2","user3"])
grant("group1", TABLE_READ, "dfs://valuedb/pt")
createUser("user4","123456")
addGroupMember("user4","group1")
grant("user1", TABLE_WRITE, "dfs://valuedb/pt")
grant("user4", TABLE_WRITE, "dfs://valuedb/pt")

此时 user1 和 user4 拥有对 "dfs://valuedb/pt" 表的增删改查权限，user2 和 user3 只有对其查看的权限。

例 7：可以使用 grant 或 deny 对所有对象 (以*代表) 赋予或禁止权限。例如，赋予用户 JoeFlacco 可读任何 DFS 数据表的权限：

grant("JoeFlacco",TABLE_READ,"*")  

当 grant 或 deny 所有对象后，若要撤销操作，只能使用 revoke 撤销所有对象的权限，若只撤销某个指定对象的权限，则操作无效：

revoke("JoeFlacco",TABLE_READ,"dfs://db1/t1")

以上命令无效。

revoke("JoeFlacco",TABLE_READ,"*")

以上命令取消了用户 JoeFlacco 可读任何 DFS 数据表的权限。

与之类似，使用 grant 或 deny 对组赋予或禁止权限后，只能对该组使用 revoke 来取消该权限设置。若对某个组员使用 revoke 来取消该权限，则无法生效。

例 8：有 DB_OWNER 权限的用户可以赋予别的用户对自己创建的数据库的权限。

管理员创建了两个用户，CliffLee 和 MitchTrubisky，其中用户 MitchTrubisky 拥有 DB_OWNER 的权限：

createUser(`CliffLee, "GH456$%")
createUser(`MitchTrubisky, "JI3564^")
grant(`MitchTrubisky,DB_OWNER);

MitchTrubisky 创建数据表 "dfs://dbMT/dt", 并赋予用户 CliffLee 读取该数据表的权限：

login(`MitchTrubisky, "JI3564^");
db = database("dfs://dbMT", VALUE, 1..10)
t=table(1..1000 as id, rand(100, 1000) as x)
dt = db.createTable(t, "dt").append!(t)
grant(`CliffLee, TABLE_READ, "dfs://dbMT/dt"); 

尽管用户 CliffLee 之前没有被系统管理员赋予任何权限，但是 CliffLee 最后的权限为：可以访问 MitchTrubisky 创建的数据表 "dfs://dbMT/dt"。

共享内存表会被共享到所有会话中，因此也会有权限管理的需求。系统支持对共享内存表进行写入和读取的权限管理，语法与数据库表权限管理一致。其中accessType 仅支持 TABLE_READ 和 TABLE_WRITE，分别表示对共享内存表的读和增删改权限。

注意：

• 只有创建表的用户或者管理员可以限制其他用户对该表的操作权限
• 若用户使用 addAccessControl 函数限制其他用户访问该用户创建的共享表，其他用户只有被管理员赋予访问权限后，才可访问该用户创建的共享表
• 如果管理员已经为其他用户 grant / deny / revoke 该表的权限，则该表自动添加权限限制，其他未经授权的用户无法再访问该表

例子：

创建管理员 MitchTrubisky，登录 MitchTrubisky 并创建共享内存表 trades：

login(`admin, "123456");
createUser("MitchTrubisky","JI3564^",,true)
login(`MitchTrubisky, "JI3564^")
share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades

此时所有用户都有读写 st1 表的权限：

createUser("CliffLee","JI3564^",,false)
login("CliffLee","JI3564^")
insert into trades values(1970.01.01T00:00:00.001,`sym,1)
select * from trades

赋予用户 CliffLee 读取 trades 表的权限：

login(`MitchTrubisky, "JI3564^")
grant("CliffLee", TABLE_READ, "trades") 

此时用户 CliffLee 拥有读取权限而写入则没有权限：

login("CliffLee","JI3564^")
select * from trades
insert into trades values(1970.01.01T00:00:00.001,`sym,1) => No access to table [trades]

如上对该表进行过第一次权限操作之后，该表自动添加权限限制。此时只有管理员和表创建者 MitchTrubisky 对该表有读写权限。

也可以取消用户 CliffLee 读取的权限：

login(`MitchTrubisky, "JI3564^")
revoke("CliffLee", TABLE_READ, "trades")
login("CliffLee","JI3564^")
select * from trades => No access to shared table [trades]

若在建表后希望仅自己和管理员对共享内存表有访问权限，可以使用 addAccessControl 对于表增加权限控制：

share table(1:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as st2
addAccessControl(st2)

函数视图提供了一种灵活的方式来控制用户访问数据库和表。在视图的基础上，函数视图提供了函数功能，可以同时访问数据库并进行相关计算。

注意：

• 只有系统管理员有创建和删除函数视图的权限。用户即使不具备读写数据库原始数据的权限，也可通过执行函数视图，间接访问数据库，得到所需计算结果
• 如果函数视图和本地的函数重名，调用时系统会解析为本地函数
• 某些操作只需要 VIEW_EXEC 权限就可以在 FunctionView 中执行，详见表 DDL 和 DML 相关函数
• VIEW_EXEC 的权限作用对象（objs）由高到低分为全局 (*)、命名空间 (<namespace>::*)、函数视图三个层级。

例 1：管理员定义一个函数视图：

def countTradeAll(){  
	return exec count(*) from loadTable("dfs://TAQ","Trades")  
}
addFunctionView(countTradeAll)  
grant("NickFoles",VIEW_EXEC,"countTradeAll")  

以用户名 NickFoles 登录，执行视图 "countTradeAll"：

countTradeAll()

在此例中，虽然用户 NickFoles 没有访问表 "dfs://TAQ/Trades" 的权限，但是可以运行函数视图 "countTradeAll" 获取表的行数。

例 2：函数视图也可以带参数。用户在使用的时候可以输入参数获取相应的结果。

创建一个函数视图，获取某一个股票在某一天的所有交易记录：

def getTrades(s, d){
	return select * from loadTable("dfs://TAQ","Trades") where sym=s, date=d
}
addFunctionView(getTrades)
grant("NickFoles",VIEW_EXEC,"getTrades")  

同样在此例中，用户 NickFoles 没有访问表"dfs://TAQ/Trades"的权限，但是可以执行视图“getTrades”，指定股票代码 IBM 和日期 2018.07.09，获得 IBM 在 2018.07.09 这一天的所有交易记录：

getTrades("IBM", 2018.07.09)

定时作业是指用户指定在特定的时间，以特定的频率执行一系列任务，多用于批处理类业务场景。

• 当用户创建定时作业（函数 scheduleJob）时，若作业中包含库/表的读写或修改操作，不需要具备相关的权限也能成功创建。但执行定时作业时，需要具备与对象相关的权限，否则无法执行
• 系统管理员可以 deleteScheduledJob 删除其他用户定时作业，非管理员用户只能删除自己创建的定时作业

login("NickFoles","AB123!@")  
def readTable(){
	read_t1=loadTable("dfs://db1","t1")  
	return exec count(*) from read_t1  
}
scheduleJob("readTableJob","read DFS table",readTable,minute(now()),date(now()),date(now())+1,'D');

不管 NickFoles 有没有读 "dfs://db1/t1" 的权限，"readTable" 任务都能设置成功。

在 "readTable" 任务实际运行时，如果用户 NickFoles 有读 "dfs://db1/t1" 的权限，则成功执行，否则鉴权失败。

SCRIPT_EXEC，TEST_EXEC 权限作用范围为全局。

用户执行 run 函数，或在客户端运行脚本都需要 SCRIPT_EXEC 权限：

login(`admin, `123456)
createUser(`user1, "123456");
grant(`user1,SCRIPT_EXEC)
login(`user1, "123456")
run("test.txt")

用户执行 test函数，或在客户端执行 unittest 都需要 TEST_EXEC 权限：

login(`admin, `123456)
createUser(`user1, "123456");
grant(`user1,TEST_EXEC)
login(`user1, "123456")
test("test.txt")

grant 指定 accessType = QUERY_RESULT_MEM_LIMIT 来限制某个用户查询返回结果的内存上限和 accessType = TASK_GROUP_MEM_LIMIT 限制发送的批量子查询占用的内存上限，等同于 setMemLimitOfQueryResult 函数和 setMemLimitOfTaskGroupResult 函数，区别在于 grant 只对指定用户生效（暂不支持用户组），setMemLimitOfQueryResult 函数和 setMemLimitOfTaskGroupResult 函数对所有用户生效。

下述脚本限制用户“AlexSmith”查询时，查询结果所占用的内存大小不能超过 4 GB：

grant("AlexSmith", QUERY_RESULT_MEM_LIMIT, 4)

下述脚本限制用户“AlexSmith”查询时，发送的批量子查询占用的内存不能超过 4 GB：

grant("AlexSmith", TASK_GROUP_MEM_LIMIT, 4)

DolphinDB 提供两种配置 HTTPS 的方法：

• 在控制节点的配置文件中添加 enableHTTPS=true
• 在启动控制节点的命令行添加 -enableHTTPS true

./dolphindb -enableHTTPS true -home master -publicName www.psui.com -mode controller -localSite 192.168.1.30:8500:rh8500 -logFile ./log/master.log

DolphinDB 使用服务端证书验证的安全策略。默认情况下，会生成自制证书，客户需要安装服务端的证书，否则浏览器提示不安全连接。在集群环境中，每个节点分布在不同的物理机器上，每台物理 server 需要一份证书，因此控制节点和代理节点需要生成证书，数据节点使用同一个物理服务器上代理节点生成的证书。用户也可购买经过第三方认证的证书。