Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
taosdata
TDengine
提交
4ab55223
T
TDengine
项目概览
taosdata
/
TDengine
大约 1 年 前同步成功
通知
1184
Star
22015
Fork
4786
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
1
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
T
TDengine
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
1
Issue
1
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
4ab55223
编写于
6月 07, 2022
作者:
X
Xiaoyu Wang
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
fix: a problem of parser async
上级
cd90a9fa
变更
3
隐藏空白更改
内联
并排
Showing
3 changed file
with
113 addition
and
152 deletion
+113
-152
source/libs/parser/src/parAstParser.c
source/libs/parser/src/parAstParser.c
+1
-1
source/libs/parser/src/parUtil.c
source/libs/parser/src/parUtil.c
+79
-109
source/libs/parser/test/mockCatalogService.cpp
source/libs/parser/test/mockCatalogService.cpp
+33
-42
未找到文件。
source/libs/parser/src/parAstParser.c
浏览文件 @
4ab55223
...
...
@@ -108,7 +108,7 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt);
static
EDealRes
collectMetaKeyFromFunction
(
SCollectMetaKeyFromExprCxt
*
pCxt
,
SFunctionNode
*
pFunc
)
{
if
(
fmIsBuiltinFunc
(
pFunc
->
functionName
))
{
return
TSDB_CODE_SUCCESS
;
return
DEAL_RES_CONTINUE
;
}
pCxt
->
errCode
=
reserveUdfInCache
(
pFunc
->
functionName
,
pCxt
->
pComCxt
->
pMetaCache
);
return
TSDB_CODE_SUCCESS
==
pCxt
->
errCode
?
DEAL_RES_CONTINUE
:
DEAL_RES_ERROR
;
...
...
source/libs/parser/src/parUtil.c
浏览文件 @
4ab55223
...
...
@@ -482,20 +482,6 @@ static int32_t buildDbReq(SHashObj* pDbsHash, SArray** pDbs) {
return
TSDB_CODE_SUCCESS
;
}
static
int32_t
buildTableMetaReq
(
SHashObj
*
pTableMetaHash
,
SArray
**
pTableMeta
)
{
return
buildTableReq
(
pTableMetaHash
,
pTableMeta
);
}
static
int32_t
buildDbVgroupReq
(
SHashObj
*
pDbVgroupHash
,
SArray
**
pDbVgroup
)
{
return
buildDbReq
(
pDbVgroupHash
,
pDbVgroup
);
}
static
int32_t
buildTableVgroupReq
(
SHashObj
*
pTableVgroupHash
,
SArray
**
pTableVgroup
)
{
return
buildTableReq
(
pTableVgroupHash
,
pTableVgroup
);
}
static
int32_t
buildDbCfgReq
(
SHashObj
*
pDbCfgHash
,
SArray
**
pDbCfg
)
{
return
buildDbReq
(
pDbCfgHash
,
pDbCfg
);
}
static
int32_t
buildUserAuthReq
(
SHashObj
*
pUserAuthHash
,
SArray
**
pUserAuth
)
{
if
(
NULL
!=
pUserAuthHash
)
{
*
pUserAuth
=
taosArrayInit
(
taosHashGetSize
(
pUserAuthHash
),
sizeof
(
SUserAuthInfo
));
...
...
@@ -535,15 +521,18 @@ static int32_t buildUdfReq(SHashObj* pUdfHash, SArray** pUdf) {
}
int32_t
buildCatalogReq
(
const
SParseMetaCache
*
pMetaCache
,
SCatalogReq
*
pCatalogReq
)
{
int32_t
code
=
buildTableMetaReq
(
pMetaCache
->
pTableMeta
,
&
pCatalogReq
->
pTableMeta
);
int32_t
code
=
buildTableReq
(
pMetaCache
->
pTableMeta
,
&
pCatalogReq
->
pTableMeta
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
buildDbReq
(
pMetaCache
->
pDbVgroup
,
&
pCatalogReq
->
pDbVgroup
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
build
DbVgroupReq
(
pMetaCache
->
pDbVgroup
,
&
pCatalogReq
->
pDbVgroup
);
code
=
build
TableReq
(
pMetaCache
->
pTableVgroup
,
&
pCatalogReq
->
pTableHash
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
build
TableVgroupReq
(
pMetaCache
->
pTableVgroup
,
&
pCatalogReq
->
pTableHash
);
code
=
build
DbReq
(
pMetaCache
->
pDbCfg
,
&
pCatalogReq
->
pDbCfg
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
buildDb
CfgReq
(
pMetaCache
->
pDbCfg
,
&
pCatalogReq
->
pDbCfg
);
code
=
buildDb
Req
(
pMetaCache
->
pDbInfo
,
&
pCatalogReq
->
pDbInfo
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
buildUserAuthReq
(
pMetaCache
->
pUserAuth
,
&
pCatalogReq
->
pUser
);
...
...
@@ -554,51 +543,39 @@ int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalog
return
code
;
}
static
int32_t
putTableMetaToCache
(
const
SArray
*
pTableMetaReq
,
const
SArray
*
pTableMetaData
,
SHashObj
*
pTableMeta
)
{
int32_t
ntables
=
taosArrayGetSize
(
pTableMetaReq
);
for
(
int32_t
i
=
0
;
i
<
ntables
;
++
i
)
{
char
fullName
[
TSDB_TABLE_FNAME_LEN
];
tNameExtractFullName
(
taosArrayGet
(
pTableMetaReq
,
i
),
fullName
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pTableMeta
,
fullName
,
strlen
(
fullName
),
taosArrayGet
(
pTableMetaData
,
i
),
POINTER_BYTES
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
}
return
TSDB_CODE_SUCCESS
;
static
int32_t
putMetaDataToHash
(
const
char
*
pKey
,
int32_t
len
,
const
SArray
*
pData
,
int32_t
index
,
SHashObj
*
pHash
)
{
SMetaRes
*
pRes
=
taosArrayGet
(
pData
,
index
);
return
taosHashPut
(
pHash
,
pKey
,
len
,
&
pRes
,
POINTER_BYTES
);
}
static
int32_t
putDbVgroupToCache
(
const
SArray
*
pDbVgroupReq
,
const
SArray
*
pDbVgroupData
,
SHashObj
*
pDbVgroup
)
{
int32_t
nvgs
=
taosArrayGetSize
(
pDbVgroupReq
);
for
(
int32_t
i
=
0
;
i
<
nvgs
;
++
i
)
{
char
*
pDbFName
=
taosArrayGet
(
pDbVgroupReq
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pDbVgroup
,
pDbFName
,
strlen
(
pDbFName
),
taosArrayGet
(
pDbVgroupData
,
i
),
POINTER_BYTES
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
static
int32_t
getMetaDataFromHash
(
const
char
*
pKey
,
int32_t
len
,
SHashObj
*
pHash
,
void
**
pOutput
)
{
SMetaRes
**
pRes
=
taosHashGet
(
pHash
,
pKey
,
len
);
if
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
}
return
TSDB_CODE_SUCCESS
;
if
(
TSDB_CODE_SUCCESS
==
(
*
pRes
)
->
code
)
{
*
pOutput
=
(
*
pRes
)
->
pRes
;
}
return
(
*
pRes
)
->
code
;
}
static
int32_t
putTableVgroupToCache
(
const
SArray
*
pTableVgroupReq
,
const
SArray
*
pTableVgroupData
,
SHashObj
*
pTableVgroup
)
{
int32_t
ntables
=
taosArrayGetSize
(
pTableVgroupReq
);
static
int32_t
putTableDataToCache
(
const
SArray
*
pTableReq
,
const
SArray
*
pTableData
,
SHashObj
*
pTable
)
{
int32_t
ntables
=
taosArrayGetSize
(
pTableReq
);
for
(
int32_t
i
=
0
;
i
<
ntables
;
++
i
)
{
char
fullName
[
TSDB_TABLE_FNAME_LEN
];
tNameExtractFullName
(
taosArrayGet
(
pTableVgroupReq
,
i
),
fullName
);
SVgroupInfo
*
pInfo
=
taosArrayGet
(
pTableVgroupData
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pTableVgroup
,
fullName
,
strlen
(
fullName
),
&
pInfo
,
POINTER_BYTES
))
{
tNameExtractFullName
(
taosArrayGet
(
pTableReq
,
i
),
fullName
);
if
(
TSDB_CODE_SUCCESS
!=
putMetaDataToHash
(
fullName
,
strlen
(
fullName
),
pTableData
,
i
,
pTable
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
}
return
TSDB_CODE_SUCCESS
;
}
static
int32_t
putDb
CfgToCache
(
const
SArray
*
pDbCfgReq
,
const
SArray
*
pDbCfgData
,
SHashObj
*
pDbCfg
)
{
int32_t
nvgs
=
taosArrayGetSize
(
pDb
Cfg
Req
);
static
int32_t
putDb
DataToCache
(
const
SArray
*
pDbReq
,
const
SArray
*
pDbData
,
SHashObj
*
pDb
)
{
int32_t
nvgs
=
taosArrayGetSize
(
pDbReq
);
for
(
int32_t
i
=
0
;
i
<
nvgs
;
++
i
)
{
char
*
pDbFName
=
taosArrayGet
(
pDbCfgReq
,
i
);
SDbCfgInfo
*
pInfo
=
taosArrayGet
(
pDbCfgData
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pDbCfg
,
pDbFName
,
strlen
(
pDbFName
),
&
pInfo
,
POINTER_BYTES
))
{
char
*
pDbFName
=
taosArrayGet
(
pDbReq
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
putMetaDataToHash
(
pDbFName
,
strlen
(
pDbFName
),
pDbData
,
i
,
pDb
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
}
...
...
@@ -611,7 +588,7 @@ static int32_t putUserAuthToCache(const SArray* pUserAuthReq, const SArray* pUse
SUserAuthInfo
*
pUser
=
taosArrayGet
(
pUserAuthReq
,
i
);
char
key
[
USER_AUTH_KEY_MAX_LEN
]
=
{
0
};
int32_t
len
=
userAuthToStringExt
(
pUser
->
user
,
pUser
->
dbFName
,
pUser
->
type
,
key
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pUserAuth
,
key
,
len
,
taosArrayGet
(
pUserAuthData
,
i
),
sizeof
(
bool
)
))
{
if
(
TSDB_CODE_SUCCESS
!=
putMetaDataToHash
(
key
,
len
,
pUserAuthData
,
i
,
pUserAuth
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
}
...
...
@@ -621,9 +598,8 @@ static int32_t putUserAuthToCache(const SArray* pUserAuthReq, const SArray* pUse
static
int32_t
putUdfToCache
(
const
SArray
*
pUdfReq
,
const
SArray
*
pUdfData
,
SHashObj
*
pUdf
)
{
int32_t
num
=
taosArrayGetSize
(
pUdfReq
);
for
(
int32_t
i
=
0
;
i
<
num
;
++
i
)
{
char
*
pFunc
=
taosArrayGet
(
pUdfReq
,
i
);
SFuncInfo
*
pInfo
=
taosArrayGet
(
pUdfData
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
taosHashPut
(
pUdf
,
pFunc
,
strlen
(
pFunc
),
&
pInfo
,
POINTER_BYTES
))
{
char
*
pFunc
=
taosArrayGet
(
pUdfReq
,
i
);
if
(
TSDB_CODE_SUCCESS
!=
putMetaDataToHash
(
pFunc
,
strlen
(
pFunc
),
pUdfData
,
i
,
pUdf
))
{
return
TSDB_CODE_OUT_OF_MEMORY
;
}
}
...
...
@@ -631,15 +607,18 @@ static int32_t putUdfToCache(const SArray* pUdfReq, const SArray* pUdfData, SHas
}
int32_t
putMetaDataToCache
(
const
SCatalogReq
*
pCatalogReq
,
const
SMetaData
*
pMetaData
,
SParseMetaCache
*
pMetaCache
)
{
int32_t
code
=
putTableMetaToCache
(
pCatalogReq
->
pTableMeta
,
pMetaData
->
pTableMeta
,
pMetaCache
->
pTableMeta
);
int32_t
code
=
putTableDataToCache
(
pCatalogReq
->
pTableMeta
,
pMetaData
->
pTableMeta
,
pMetaCache
->
pTableMeta
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
putDbDataToCache
(
pCatalogReq
->
pDbVgroup
,
pMetaData
->
pDbVgroup
,
pMetaCache
->
pDbVgroup
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
put
DbVgroupToCache
(
pCatalogReq
->
pDbVgroup
,
pMetaData
->
pDbVgroup
,
pMetaCache
->
pDb
Vgroup
);
code
=
put
TableDataToCache
(
pCatalogReq
->
pTableHash
,
pMetaData
->
pTableHash
,
pMetaCache
->
pTable
Vgroup
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
put
TableVgroupToCache
(
pCatalogReq
->
pTableHash
,
pMetaData
->
pTableHash
,
pMetaCache
->
pTableVgroup
);
code
=
put
DbDataToCache
(
pCatalogReq
->
pDbCfg
,
pMetaData
->
pDbCfg
,
pMetaCache
->
pDbCfg
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
putDb
CfgToCache
(
pCatalogReq
->
pDbCfg
,
pMetaData
->
pDbCfg
,
pMetaCache
->
pDbCfg
);
code
=
putDb
DataToCache
(
pCatalogReq
->
pDbInfo
,
pMetaData
->
pDbInfo
,
pMetaCache
->
pDbInfo
);
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
code
=
putUserAuthToCache
(
pCatalogReq
->
pUser
,
pMetaData
->
pUser
,
pMetaCache
->
pUserAuth
);
...
...
@@ -679,16 +658,15 @@ int32_t reserveTableMetaInCacheExt(const SName* pName, SParseMetaCache* pMetaCac
int32_t
getTableMetaFromCache
(
SParseMetaCache
*
pMetaCache
,
const
SName
*
pName
,
STableMeta
**
pMeta
)
{
char
fullName
[
TSDB_TABLE_FNAME_LEN
];
tNameExtractFullName
(
pName
,
fullName
);
STableMeta
**
pRes
=
taosHashGet
(
pMetaCache
->
pTableMeta
,
fullName
,
strlen
(
fullName
));
if
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
parserError
(
"getTableMetaFromCache error: %s"
,
fullName
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
}
*
pMeta
=
tableMetaDup
(
*
pRes
);
if
(
NULL
==
*
pMeta
)
{
return
TSDB_CODE_OUT_OF_MEMORY
;
STableMeta
*
pTableMeta
=
NULL
;
int32_t
code
=
getMetaDataFromHash
(
fullName
,
strlen
(
fullName
),
pMetaCache
->
pTableMeta
,
(
void
**
)
&
pTableMeta
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
*
pMeta
=
tableMetaDup
(
pTableMeta
);
if
(
NULL
==
*
pMeta
)
{
code
=
TSDB_CODE_OUT_OF_MEMORY
;
}
}
return
TSDB_CODE_SUCCESS
;
return
code
;
}
static
int32_t
reserveDbReqInCache
(
int32_t
acctId
,
const
char
*
pDb
,
SHashObj
**
pDbs
)
{
...
...
@@ -708,19 +686,16 @@ int32_t reserveDbVgInfoInCache(int32_t acctId, const char* pDb, SParseMetaCache*
}
int32_t
getDbVgInfoFromCache
(
SParseMetaCache
*
pMetaCache
,
const
char
*
pDbFName
,
SArray
**
pVgInfo
)
{
SArray
**
pRes
=
taosHashGet
(
pMetaCache
->
pDbVgroup
,
pDbFName
,
strlen
(
pDbFName
));
if
(
NULL
==
pRes
)
{
parserError
(
"getDbVgInfoFromCache error: %s"
,
pDbFName
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
}
// *pRes is null, which is a legal value, indicating that the user DB has not been created
if
(
NULL
!=
*
pRes
)
{
*
pVgInfo
=
taosArrayDup
(
*
pRes
);
SArray
*
pVgList
=
NULL
;
int32_t
code
=
getMetaDataFromHash
(
pDbFName
,
strlen
(
pDbFName
),
pMetaCache
->
pDbVgroup
,
(
void
**
)
&
pVgList
);
// pVgList is null, which is a legal value, indicating that the user DB has not been created
if
(
TSDB_CODE_SUCCESS
==
code
&&
NULL
!=
pVgList
)
{
*
pVgInfo
=
taosArrayDup
(
pVgList
);
if
(
NULL
==
*
pVgInfo
)
{
return
TSDB_CODE_OUT_OF_MEMORY
;
code
=
TSDB_CODE_OUT_OF_MEMORY
;
}
}
return
TSDB_CODE_SUCCESS
;
return
code
;
}
int32_t
reserveTableVgroupInCache
(
int32_t
acctId
,
const
char
*
pDb
,
const
char
*
pTable
,
SParseMetaCache
*
pMetaCache
)
{
...
...
@@ -736,30 +711,28 @@ int32_t reserveTableVgroupInCacheExt(const SName* pName, SParseMetaCache* pMetaC
int32_t
getTableVgroupFromCache
(
SParseMetaCache
*
pMetaCache
,
const
SName
*
pName
,
SVgroupInfo
*
pVgroup
)
{
char
fullName
[
TSDB_TABLE_FNAME_LEN
];
tNameExtractFullName
(
pName
,
fullName
);
SVgroupInfo
*
*
pRes
=
taosHashGet
(
pMetaCache
->
pTableVgroup
,
fullName
,
strlen
(
fullName
))
;
i
f
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
parserError
(
"getTableVgroupFromCache error: %s"
,
fullName
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
SVgroupInfo
*
pVg
=
NULL
;
i
nt32_t
code
=
getMetaDataFromHash
(
fullName
,
strlen
(
fullName
),
pMetaCache
->
pTableVgroup
,
(
void
**
)
&
pVg
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
memcpy
(
pVgroup
,
pVg
,
sizeof
(
SVgroupInfo
))
;
}
memcpy
(
pVgroup
,
*
pRes
,
sizeof
(
SVgroupInfo
));
return
TSDB_CODE_SUCCESS
;
return
code
;
}
int32_t
reserveDbVgVersionInCache
(
int32_t
acctId
,
const
char
*
pDb
,
SParseMetaCache
*
pMetaCache
)
{
return
reserveDbReqInCache
(
acctId
,
pDb
,
&
pMetaCache
->
pDb
Cfg
);
return
reserveDbReqInCache
(
acctId
,
pDb
,
&
pMetaCache
->
pDb
Info
);
}
int32_t
getDbVgVersionFromCache
(
SParseMetaCache
*
pMetaCache
,
const
char
*
pDbFName
,
int32_t
*
pVersion
,
int64_t
*
pDbId
,
int32_t
*
pTableNum
)
{
SDbInfo
**
pRes
=
taosHashGet
(
pMetaCache
->
pDbCfg
,
pDbFName
,
strlen
(
pDbFName
));
if
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
parserError
(
"getDbVgVersionFromCache error: %s"
,
pDbFName
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
SDbInfo
*
pDbInfo
=
NULL
;
int32_t
code
=
getMetaDataFromHash
(
pDbFName
,
strlen
(
pDbFName
),
pMetaCache
->
pDbInfo
,
(
void
**
)
&
pDbInfo
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
*
pVersion
=
pDbInfo
->
vgVer
;
*
pDbId
=
pDbInfo
->
dbId
;
*
pTableNum
=
pDbInfo
->
tbNum
;
}
*
pVersion
=
(
*
pRes
)
->
vgVer
;
*
pDbId
=
(
*
pRes
)
->
dbId
;
*
pTableNum
=
(
*
pRes
)
->
tbNum
;
return
TSDB_CODE_SUCCESS
;
return
code
;
}
int32_t
reserveDbCfgInCache
(
int32_t
acctId
,
const
char
*
pDb
,
SParseMetaCache
*
pMetaCache
)
{
...
...
@@ -767,13 +740,12 @@ int32_t reserveDbCfgInCache(int32_t acctId, const char* pDb, SParseMetaCache* pM
}
int32_t
getDbCfgFromCache
(
SParseMetaCache
*
pMetaCache
,
const
char
*
pDbFName
,
SDbCfgInfo
*
pInfo
)
{
SDbCfgInfo
*
*
pRes
=
taosHashGet
(
pMetaCache
->
pDbCfg
,
pDbFName
,
strlen
(
pDbFName
))
;
i
f
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
parserError
(
"getDbCfgFromCache error: %s"
,
pDbFName
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
SDbCfgInfo
*
pDbCfg
=
NULL
;
i
nt32_t
code
=
getMetaDataFromHash
(
pDbFName
,
strlen
(
pDbFName
),
pMetaCache
->
pDbCfg
,
(
void
**
)
&
pDbCfg
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
memcpy
(
pInfo
,
pDbCfg
,
sizeof
(
SDbCfgInfo
))
;
}
memcpy
(
pInfo
,
*
pRes
,
sizeof
(
SDbCfgInfo
));
return
TSDB_CODE_SUCCESS
;
return
code
;
}
static
int32_t
reserveUserAuthInCacheImpl
(
const
char
*
pKey
,
int32_t
len
,
SParseMetaCache
*
pMetaCache
)
{
...
...
@@ -806,13 +778,12 @@ int32_t getUserAuthFromCache(SParseMetaCache* pMetaCache, const char* pUser, con
bool
*
pPass
)
{
char
key
[
USER_AUTH_KEY_MAX_LEN
]
=
{
0
};
int32_t
len
=
userAuthToStringExt
(
pUser
,
pDbFName
,
type
,
key
);
bool
*
pRes
=
taosHashGet
(
pMetaCache
->
pUserAuth
,
key
,
len
)
;
i
f
(
NULL
==
pRes
)
{
parserError
(
"getUserAuthFromCache error: %s, %s, %d"
,
pUser
,
pDbFName
,
type
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
bool
*
pRes
=
NULL
;
i
nt32_t
code
=
getMetaDataFromHash
(
key
,
len
,
pMetaCache
->
pUserAuth
,
(
void
**
)
&
pRes
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
*
pPass
=
*
pRes
;
}
*
pPass
=
*
pRes
;
return
TSDB_CODE_SUCCESS
;
return
code
;
}
int32_t
reserveUdfInCache
(
const
char
*
pFunc
,
SParseMetaCache
*
pMetaCache
)
{
...
...
@@ -826,11 +797,10 @@ int32_t reserveUdfInCache(const char* pFunc, SParseMetaCache* pMetaCache) {
}
int32_t
getUdfInfoFromCache
(
SParseMetaCache
*
pMetaCache
,
const
char
*
pFunc
,
SFuncInfo
*
pInfo
)
{
SFuncInfo
*
*
pRes
=
taosHashGet
(
pMetaCache
->
pUdf
,
pFunc
,
strlen
(
pFunc
))
;
i
f
(
NULL
==
pRes
||
NULL
==
*
pRes
)
{
parserError
(
"getUdfInfoFromCache error: %s"
,
pFunc
);
return
TSDB_CODE_PAR_INTERNAL_ERROR
;
SFuncInfo
*
pFuncInfo
=
NULL
;
i
nt32_t
code
=
getMetaDataFromHash
(
pFunc
,
strlen
(
pFunc
),
pMetaCache
->
pUdf
,
(
void
**
)
&
pFuncInfo
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
memcpy
(
pInfo
,
pFuncInfo
,
sizeof
(
SFuncInfo
))
;
}
memcpy
(
pInfo
,
*
pRes
,
sizeof
(
SFuncInfo
));
return
TSDB_CODE_SUCCESS
;
return
code
;
}
source/libs/parser/test/mockCatalogService.cpp
浏览文件 @
4ab55223
...
...
@@ -367,49 +367,40 @@ class MockCatalogServiceImpl {
}
int32_t
getAllTableMeta
(
SArray
*
pTableMetaReq
,
SArray
**
pTableMetaData
)
const
{
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pTableMetaReq
)
{
int32_t
ntables
=
taosArrayGetSize
(
pTableMetaReq
);
*
pTableMetaData
=
taosArrayInit
(
ntables
,
POINTER_BYTES
);
*
pTableMetaData
=
taosArrayInit
(
ntables
,
sizeof
(
SMetaRes
)
);
for
(
int32_t
i
=
0
;
i
<
ntables
;
++
i
)
{
STableMeta
*
pMeta
=
NULL
;
code
=
catalogGetTableMeta
((
const
SName
*
)
taosArrayGet
(
pTableMetaReq
,
i
),
&
pMeta
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
taosArrayPush
(
*
pTableMetaData
,
&
pMeta
);
}
else
{
break
;
}
SMetaRes
res
=
{
0
};
res
.
code
=
catalogGetTableMeta
((
const
SName
*
)
taosArrayGet
(
pTableMetaReq
,
i
),
(
STableMeta
**
)
&
res
.
pRes
);
taosArrayPush
(
*
pTableMetaData
,
&
res
);
}
}
return
code
;
return
TSDB_CODE_SUCCESS
;
}
int32_t
getAllTableVgroup
(
SArray
*
pTableVgroupReq
,
SArray
**
pTableVgroupData
)
const
{
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pTableVgroupReq
)
{
int32_t
ntables
=
taosArrayGetSize
(
pTableVgroupReq
);
*
pTableVgroupData
=
taosArrayInit
(
ntables
,
sizeof
(
S
VgroupInfo
));
*
pTableVgroupData
=
taosArrayInit
(
ntables
,
sizeof
(
S
MetaRes
));
for
(
int32_t
i
=
0
;
i
<
ntables
;
++
i
)
{
SVgroupInfo
vgInfo
=
{
0
};
code
=
catalogGetTableHashVgroup
((
const
SName
*
)
taosArrayGet
(
pTableVgroupReq
,
i
),
&
vgInfo
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
taosArrayPush
(
*
pTableVgroupData
,
&
vgInfo
);
}
else
{
break
;
}
SMetaRes
res
=
{
0
};
res
.
pRes
=
taosMemoryCalloc
(
1
,
sizeof
(
SVgroupInfo
));
res
.
code
=
catalogGetTableHashVgroup
((
const
SName
*
)
taosArrayGet
(
pTableVgroupReq
,
i
),
(
SVgroupInfo
*
)
res
.
pRes
);
taosArrayPush
(
*
pTableVgroupData
,
&
res
);
}
}
return
code
;
return
TSDB_CODE_SUCCESS
;
}
int32_t
getAllDbVgroup
(
SArray
*
pDbVgroupReq
,
SArray
**
pDbVgroupData
)
const
{
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pDbVgroupReq
)
{
int32_t
ndbs
=
taosArrayGetSize
(
pDbVgroupReq
);
*
pDbVgroupData
=
taosArrayInit
(
ndbs
,
POINTER_BYTES
);
*
pDbVgroupData
=
taosArrayInit
(
ndbs
,
sizeof
(
SMetaRes
)
);
for
(
int32_t
i
=
0
;
i
<
ndbs
;
++
i
)
{
int64_t
zeroVg
=
0
;
taosArrayPush
(
*
pDbVgroupData
,
&
zeroVg
);
SMetaRes
res
=
{
0
}
;
taosArrayPush
(
*
pDbVgroupData
,
&
res
);
}
}
return
code
;
...
...
@@ -419,10 +410,11 @@ class MockCatalogServiceImpl {
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pDbCfgReq
)
{
int32_t
ndbs
=
taosArrayGetSize
(
pDbCfgReq
);
*
pDbCfgData
=
taosArrayInit
(
ndbs
,
sizeof
(
S
DbCfgInfo
));
*
pDbCfgData
=
taosArrayInit
(
ndbs
,
sizeof
(
S
MetaRes
));
for
(
int32_t
i
=
0
;
i
<
ndbs
;
++
i
)
{
SDbCfgInfo
dbCfg
=
{
0
};
taosArrayPush
(
*
pDbCfgData
,
&
dbCfg
);
SMetaRes
res
=
{
0
};
res
.
pRes
=
taosMemoryCalloc
(
1
,
sizeof
(
SDbCfgInfo
));
taosArrayPush
(
*
pDbCfgData
,
&
res
);
}
}
return
code
;
...
...
@@ -432,10 +424,11 @@ class MockCatalogServiceImpl {
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pDbInfoReq
)
{
int32_t
ndbs
=
taosArrayGetSize
(
pDbInfoReq
);
*
pDbInfoData
=
taosArrayInit
(
ndbs
,
sizeof
(
S
DbCfgInfo
));
*
pDbInfoData
=
taosArrayInit
(
ndbs
,
sizeof
(
S
MetaRes
));
for
(
int32_t
i
=
0
;
i
<
ndbs
;
++
i
)
{
SDbInfo
dbInfo
=
{
0
};
taosArrayPush
(
*
pDbInfoData
,
&
dbInfo
);
SMetaRes
res
=
{
0
};
res
.
pRes
=
taosMemoryCalloc
(
1
,
sizeof
(
SDbInfo
));
taosArrayPush
(
*
pDbInfoData
,
&
res
);
}
}
return
code
;
...
...
@@ -445,31 +438,29 @@ class MockCatalogServiceImpl {
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pUserAuthReq
)
{
int32_t
num
=
taosArrayGetSize
(
pUserAuthReq
);
*
pUserAuthData
=
taosArrayInit
(
num
,
sizeof
(
bool
));
*
pUserAuthData
=
taosArrayInit
(
num
,
sizeof
(
SMetaRes
));
for
(
int32_t
i
=
0
;
i
<
num
;
++
i
)
{
bool
pass
=
true
;
taosArrayPush
(
*
pUserAuthData
,
&
pass
);
SMetaRes
res
=
{
0
};
res
.
pRes
=
taosMemoryCalloc
(
1
,
sizeof
(
bool
));
*
(
bool
*
)(
res
.
pRes
)
=
true
;
taosArrayPush
(
*
pUserAuthData
,
&
res
);
}
}
return
code
;
}
int32_t
getAllUdf
(
SArray
*
pUdfReq
,
SArray
**
pUdfData
)
const
{
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
NULL
!=
pUdfReq
)
{
int32_t
num
=
taosArrayGetSize
(
pUdfReq
);
*
pUdfData
=
taosArrayInit
(
num
,
sizeof
(
S
FuncInfo
));
*
pUdfData
=
taosArrayInit
(
num
,
sizeof
(
S
MetaRes
));
for
(
int32_t
i
=
0
;
i
<
num
;
++
i
)
{
SFuncInfo
info
=
{
0
};
code
=
catalogGetUdfInfo
((
char
*
)
taosArrayGet
(
pUdfReq
,
i
),
&
info
);
if
(
TSDB_CODE_SUCCESS
==
code
)
{
taosArrayPush
(
*
pUdfData
,
&
info
);
}
else
{
break
;
}
SMetaRes
res
=
{
0
};
res
.
pRes
=
taosMemoryCalloc
(
1
,
sizeof
(
SFuncInfo
));
res
.
code
=
catalogGetUdfInfo
((
char
*
)
taosArrayGet
(
pUdfReq
,
i
),
(
SFuncInfo
*
)
res
.
pRes
);
taosArrayPush
(
*
pUdfData
,
&
res
);
}
}
return
code
;
return
TSDB_CODE_SUCCESS
;
}
uint64_t
id_
;
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录