#if defined _WIN32 || defined _WINDOWS
#include <windows.h>
#endif
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#if defined _WIN32 || defined _WINDOWS
#pragma pack(push,localid,1)
#endif
#include <essapi.h>
#if defined _WIN32 || defined _WINDOWS
#pragma pack(pop,localid)
#endif
ESS_HINST_T hInst;
ESS_HCTX_T hCtx;
#define MAXQRYLEN 65536
ESS_CHAR_T qry[MAXQRYLEN];
ESS_STR_T AppName = "Sample";
ESS_STR_T DbName = "Basic";
static ESS_CHAR_T *axisnames[] =
{
"COLUMNS", "ROWS", "PAGES", "CHAPTERS", "SECTIONS"
};
void ESS_Init()
{
ESS_STS_T sts;
ESS_INIT_T InitStruct = {ESS_API_VERSION,
NULL,
0L,
255,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
0L
};
if ((sts = EssInit(&InitStruct, &hInst)) != ESS_STS_NOERR)
{
printf("EssInit failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssInit sts: %ld\n", sts);
}
void ESS_Login ()
{
ESS_STS_T sts = ESS_STS_NOERR;
ESS_USHORT_T Items;
ESS_PAPPDB_T pAppsDbs = NULL;
ESS_CHAR_T SvrName[ESS_SVRNAMELEN];
ESS_CHAR_T UserName[ESS_USERNAMELEN];
ESS_CHAR_T Password[ESS_PASSWORDLEN];
/* Initialize parameters */
strcpy(SvrName,"localhost");
strcpy(UserName,"essexer");
strcpy(Password,"password");
sts = EssLogin(hInst, SvrName, UserName, Password, &Items,
&pAppsDbs, &hCtx);
if ( (sts != 0) && (sts != 1051093L) && (sts != 1051090L) )
{
printf("EssLogin failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssLogin sts: %ld\n", sts);
}
void ESS_MdxAxis(ESS_MDX_QRYHDL_T hQry,
ESS_MDX_AXISHDL_T hAxis,
ESS_STR_T pszAxisName
)
{
ESS_STS_T sts;
ESS_ULONG_T ulNAxisDims, ulAxisSize;
ESS_ULONG_T ulNClusters, ulClusterSize, ulNClusterDims;
ESS_ULONG_T ulAxisDimCnt, ulIndex, ulPropCnt;
ESS_ULONG_T ulClusterCnt, ulClusterDimCnt;
ESS_PULONG_T ulaDimSizes;
ESS_MDX_PCLUSTERHDL_T haClusters;
ESS_MDX_CLUSTERHDL_T hCluster;
ESS_MDX_PDIMHDL_T haDims;
ESS_STR_T pszDimName, pszMbrIdentifier, pszPropName;
ESS_MDX_PMBRHDL_T haMbrs;
ESS_PULONG_T ulaNProps = NULL;
ESS_MDX_PPPROPHDL_T haaProps = NULL;
ESS_MDX_PPROPHDL_T haProps;
ESS_MDX_PROPHDL_T hProp;
ESS_MDX_PROPTYPE_T propType;
ESS_MDX_PROPVALUE_T propval;
if ((sts = EssMdxGetAxisInfo(hAxis, &ulAxisSize, &ulNAxisDims,
&haDims)) != ESS_STS_NOERR)
{
printf("EssMdxGetAxisInfo failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetAxisInfo sts: %ld\n", sts);
printf("%s Size %ld Num dims %ld\n", pszAxisName,
ulAxisSize, ulNAxisDims);
if (ulAxisSize == 0)
{
return;
}
if ((sts = EssAlloc(hInst,
ulNAxisDims * sizeof(ESS_ULONG_T),
(ESS_PPVOID_T) &ulaNProps)) != ESS_STS_NOERR)
{
printf("EssAlloc failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssAlloc sts: %ld\n", sts);
if ((sts = EssAlloc(hInst,
ulNAxisDims * sizeof(ESS_MDX_PPROPHDL_T),
(ESS_PPVOID_T) &haaProps)) != ESS_STS_NOERR)
{
printf("EssAlloc failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssAlloc sts: %ld\n", sts);
for (ulAxisDimCnt = 0; ulAxisDimCnt < ulNAxisDims;
ulAxisDimCnt++)
{
if ((sts = EssMdxGetDimInfo(haDims[ulAxisDimCnt],
&pszDimName,
&ulaNProps[ulAxisDimCnt],
&haaProps[ulAxisDimCnt])) != ESS_STS_NOERR)
{
printf("EssMdxGetDimInfo failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetDimInfo sts: %ld\n", sts);
printf("Dim %ld name %s #props %ld\n", ulAxisDimCnt,
pszDimName, ulaNProps[ulAxisDimCnt]);
haProps = haaProps[ulAxisDimCnt];
for (ulPropCnt = 0; ulPropCnt < ulaNProps[ulAxisDimCnt]; ulPropCnt++)
{
hProp = haProps[ulPropCnt];
if ((sts = EssMdxGetPropertyInfo(hProp, &pszPropName,
&propType)) != ESS_STS_NOERR)
{
printf("EssMdxGetPropertyInfo failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetPropertyInfo sts: %ld\n", sts);
printf("Property %ld type %ld name %s\n", ulPropCnt,
propType, pszPropName);
}
}
if ((sts = EssMdxGetClusters(hAxis, &ulNClusters,
&haClusters)) != ESS_STS_NOERR)
{
printf("EssMdxGetClusters failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetClusters sts: %ld\n", sts);
printf("Num clusters %ld\n", ulNClusters);
for (ulClusterCnt = 0; ulClusterCnt < ulNClusters;
ulClusterCnt++)
{
hCluster = haClusters[ulClusterCnt];
if ((sts = EssMdxGetClusterInfo(hCluster, &ulClusterSize,
&ulNClusterDims,
&ulaDimSizes)) != ESS_STS_NOERR)
{
printf("EssMdxGetClusterInfo failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetClusterInfo sts: %ld\n", sts);
printf("Cluster %ld Size %ld\n", ulClusterCnt, ulClusterSize);
for (ulClusterDimCnt = 0; ulClusterDimCnt < ulNClusterDims;
ulClusterDimCnt++)
{
printf("Cluster Dim %ld Size %ld\n", ulClusterDimCnt,
ulaDimSizes[ulClusterDimCnt]);
}
for (ulIndex = 0; ulIndex < ulClusterSize; ulIndex++)
{
if ((sts = EssMdxGetClusterMembers(hCluster, ulIndex,
&haMbrs)) != ESS_STS_NOERR)
{
printf("EssMdxGetClusterMembers failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetClusterMembers sts: %ld\n", sts);
for (ulClusterDimCnt = 0; ulClusterDimCnt < ulNClusterDims;
ulClusterDimCnt++)
{
if ((sts = EssMdxGetMbrIdentifier(haMbrs[ulClusterDimCnt],
&pszMbrIdentifier)) != ESS_STS_NOERR)
{
printf("EssMdxGetMbrIdentifier failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetMbrIdentifier sts: %ld\n", sts);
printf("Mbr %ld identifier %s\n", ulClusterDimCnt,
pszMbrIdentifier);
haProps = haaProps[ulClusterDimCnt];
for (ulPropCnt = 0;
ulPropCnt < ulaNProps[ulClusterDimCnt];
ulPropCnt++)
{
if ((sts = EssMdxGetMbrProperty(haMbrs[ulClusterDimCnt],
haProps[ulPropCnt],
&propval)) != ESS_STS_NOERR)
{
printf("EssMdxGetMbrProperty failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetMbrProperty sts: %ld\n", sts);
printf("Property %ld Type ", ulPropCnt);
switch (propval.ulPropType)
{
case ESS_MDX_PROPTYPE_ULONG:
{
printf("Ulong Value: %ld\n",
propval.value.ulData);
break;
}
case ESS_MDX_PROPTYPE_STRING:
{
printf("String Value: %s\n",
propval.value.strData);
break;
}
case ESS_MDX_PROPTYPE_BOOL:
{
printf("Bool Value: %s\n",
propval.value.bData ? "TRUE" : "FALSE");
break;
}
case ESS_MDX_PROPTYPE_DOUBLE:
{
printf("Double Value: %lf\n",
propval.value.dblData);
break;
}
case ESS_MDX_PROPTYPE_DATETIME:
{
ESS_CHAR_T tmpbuf[80];
struct tm* pTime;
pTime = gmtime((time_t*)&(propval.value.dtData));
sprintf(tmpbuf, "%02i-%02i-%04i",
pTime->tm_mon+1, pTime->tm_mday,pTime->tm_year+1900);
printf("DateTime Value: %s\n", tmpbuf);
break;
}
case ESS_MDX_PROPTYPE_NONE:
{
printf("NULL Value\n");
break;
}
}
}
}
if ((sts = EssFree(hInst, (ESS_PVOID_T) haMbrs)) != ESS_STS_NOERR)
{
printf("EssFree failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssFree sts: %ld\n", sts);
}
for (ulClusterDimCnt = 0; ulClusterDimCnt < ulNClusterDims;
ulClusterDimCnt++)
{
if ((sts = EssMdxGetClusterDimMembers(hCluster, ulClusterDimCnt,
&haMbrs)) != ESS_STS_NOERR)
{
printf("EssMdxGetClusterDimMembers failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetClusterDimMembers sts: %ld\n", sts);
for (ulIndex = 0; ulIndex < ulaDimSizes[ulClusterDimCnt];
ulIndex++)
{
if ((sts = EssMdxGetMbrIdentifier(haMbrs[ulIndex],
&pszMbrIdentifier)) != ESS_STS_NOERR)
{
printf("EssMdxGetMbrIdentifier failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetMbrIdentifier sts: %ld\n", sts);
printf("Dim %ld Mbr %ld identifier %s\n", ulClusterDimCnt,
ulIndex, pszMbrIdentifier);
}
}
}
for (ulIndex = 0; ulIndex < ulAxisSize; ulIndex++)
{
if ((sts = EssMdxGetAxisMembers(hAxis, ulIndex,
&haMbrs)) != ESS_STS_NOERR)
{
printf("EssMdxGetAxisMembers failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetAxisMembers sts: %ld\n", sts);
for (ulAxisDimCnt = 0; ulAxisDimCnt < ulNAxisDims;
ulAxisDimCnt++)
{
if ((sts = EssMdxGetMbrIdentifier(haMbrs[ulAxisDimCnt],
&pszMbrIdentifier)) != ESS_STS_NOERR)
{
printf("EssMdxGetMbrIdentifier failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetMbrIdentifier sts: %ld\n", sts);
printf("Mbr %ld identifier %s\n", ulAxisDimCnt, pszMbrIdentifier);
haProps = haaProps[ulAxisDimCnt];
for (ulPropCnt = 0;
ulPropCnt < ulaNProps[ulAxisDimCnt];
ulPropCnt++)
{
hProp = haProps[ulPropCnt];
if ((sts = EssMdxGetPropertyInfo(hProp, &pszPropName,
&propType)) != ESS_STS_NOERR)
{
printf("EssMdxGetPropertyInfo failure: %ld\n", sts);
exit ((int) sts);
}
if ((sts = EssMdxGetMbrProperty(haMbrs[ulAxisDimCnt],
hProp,
&propval)) != ESS_STS_NOERR)
{
printf("EssMdxGetMbrProperty failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetMbrProperty sts: %ld\n", sts);
printf("Property %ld Type ", ulPropCnt);
switch (propval.ulPropType)
{
case ESS_MDX_PROPTYPE_ULONG:
{
printf("Ulong Value: %ld\n",
propval.value.ulData);
break;
}
case ESS_MDX_PROPTYPE_STRING:
{
printf("String Value: %s\n",
propval.value.strData);
break;
}
case ESS_MDX_PROPTYPE_BOOL:
{
printf("Bool Value: %s\n",
propval.value.bData ? "TRUE" : "FALSE");
break;
}
case ESS_MDX_PROPTYPE_DOUBLE:
{
printf("Double Value: %lf\n",
propval.value.dblData);
break;
}
case ESS_MDX_PROPTYPE_DATETIME:
{
ESS_CHAR_T tmpbuf[80];
struct tm* pTime;
pTime = gmtime((time_t*)&(propval.value.dtData));
sprintf(tmpbuf, "%02i-%02i-%04i",
pTime->tm_mon+1, pTime->tm_mday,pTime->tm_year+1900);
printf("DateTime Value: %s\n", tmpbuf);
break;
}
case ESS_MDX_PROPTYPE_NONE:
{
printf("NULL Value\n");
break;
}
}
}
}
if ((sts = EssFree(hInst, (ESS_PVOID_T) haMbrs)) != ESS_STS_NOERR)
{
printf("EssFree failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssFree sts: %ld\n", sts);
}
if ((sts = EssFree(hInst, (ESS_PVOID_T) ulaNProps)) != ESS_STS_NOERR)
{
printf("EssFree failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssFree sts: %ld\n", sts);
if ((sts = EssFree(hInst, (ESS_PVOID_T) haaProps)) != ESS_STS_NOERR)
{
printf("EssFree failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssFree sts: %ld\n", sts);
}
void ESS_MdxQry()
{
ESS_STS_T sts;
ESS_MDX_QRYHDL_T hQry;
ESS_ULONG_T ulNAxes, ulNAxisDims, ulAxisSize, ulResultSize;
ESS_ULONG_T ulNClusters, ulClusterSize, ulNClusterDims;
ESS_ULONG_T ulAxisCnt, ulAxisDimCnt, ulIndex, ulPropCnt;
ESS_ULONG_T ulCellOffset, ulClusterCnt, ulClusterDimCnt;
ESS_MDX_CELLSTATUS_T ulCellStatus;
ESS_PULONG_T ulaDimSizes;
ESS_MDX_PCLUSTERHDL_T haClusters;
ESS_MDX_CLUSTERHDL_T hCluster;
ESS_MDX_PAXISHDL_T haAxes;
ESS_MDX_PDIMHDL_T haDims;
ESS_STR_T pszDimName, pszMbrIdentifier, pszPropName;
ESS_MDX_AXISHDL_T hAxis, hSlicerAxis;
ESS_MDX_PMBRHDL_T haMbrs;
ESS_MDX_CELLHDL_T hCell;
ESS_DOUBLE_T dValue;
ESS_BOOL_T bIsMissing, bNoAccess;
ESS_PULONG_T ulaNProps;
ESS_MDX_PPPROPHDL_T haaProps;
ESS_MDX_PPROPHDL_T haProps;
ESS_MDX_PROPHDL_T hProp;
ESS_MDX_PROPTYPE_T propType;
ESS_MDX_PROPVALUE_T propval;
if ((sts = EssMdxNewQuery(hCtx, qry, &hQry)) != ESS_STS_NOERR)
{
printf("EssMdxNewQuery failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxNewQuery sts: %ld\n", sts);
if ((sts = EssMdxSetMbrIdType(hQry, ESS_MDX_MEMBERIDTYPE_ALIAS)) !=
ESS_STS_NOERR)
{
printf("EssMdxSetMbrIdType failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxSetMbrIdType sts: %ld\n", sts);
if ((sts = EssMdxSetNeedCellStatus(hQry)) != ESS_STS_NOERR)
{
printf("EssMdxSetNeedCellStatus failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxSetNeedCellStatus sts: %ld\n", sts);
if ((sts = EssMdxExecuteQuery(hQry)) != ESS_STS_NOERR)
{
printf("EssMdxExecuteQuery failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxExecuteQuery sts: %ld\n", sts);
if ((sts = EssMdxGetAxes(hQry, &ulNAxes, &haAxes,
&hSlicerAxis)) != ESS_STS_NOERR)
{
printf("EssMdxGetAxes failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetAxes sts: %ld\n", sts);
printf("Number of axes: %ld\n", ulNAxes);
ulResultSize = 1;
for (ulAxisCnt = 0; ulAxisCnt < ulNAxes; ulAxisCnt++)
{
hAxis = haAxes[ulAxisCnt];
if ((sts = EssMdxGetAxisInfo(hAxis, &ulAxisSize, &ulNAxisDims,
&haDims)) != ESS_STS_NOERR)
{
printf("EssMdxGetAxisInfo failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetAxisInfo sts: %ld\n", sts);
printf("Axis %ld Size %ld Num dims %ld\n", ulAxisCnt,
ulAxisSize, ulNAxisDims);
ulResultSize *= ulAxisSize;
}
if (hSlicerAxis)
{
ESS_MdxAxis(hQry, hSlicerAxis, "SLICER");
}
else
{
printf("Slicer Axis is empty\n");
}
for (ulAxisCnt = 0; ulAxisCnt < ulNAxes; ulAxisCnt++)
{
hAxis = haAxes[ulAxisCnt];
ESS_MdxAxis(hQry, hAxis, axisnames[ulAxisCnt]);
}
for (ulCellOffset = 0; ulCellOffset < ulResultSize;
ulCellOffset++)
{
if ((sts = EssMdxGetCellAtOffset(hQry, ulCellOffset,
&hCell)) != ESS_STS_NOERR)
{
printf("EssMdxGetCellAtOffset failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetCellAtOffset sts: %ld\n", sts);
if ((sts = EssMdxGetValue(hCell, &bIsMissing, &bNoAccess,
&dValue)) != ESS_STS_NOERR)
{
printf("EssMdxGetValue failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetValue sts: %ld\n", sts);
if (bIsMissing)
{
printf("CellOffset %ld Value #Missing\n", ulCellOffset);
}
else if (bNoAccess)
{
printf("CellOffset %ld Value #NoAccess\n", ulCellOffset);
}
else
{
printf("CellOffset %ld Value %lf\n", ulCellOffset,
dValue);
}
if (!bNoAccess)
{
if ((sts = EssMdxGetCellStatus(hQry, hCell,
&ulCellStatus)) != ESS_STS_NOERR)
{
printf("EssMdxGetCellStatus failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxGetCellStatus sts: %ld\n", sts);
if (ulCellStatus & ESS_MDX_CELLSTATUS_LINKEDOBJS)
{
printf("Cell status: LINKEDOBJS\n");
}
if (ulCellStatus & ESS_MDX_CELLSTATUS_DYNCALC)
{
printf("Cell status: DYNCALC\n");
}
if (ulCellStatus & ESS_MDX_CELLSTATUS_CALCEDMBR)
{
printf("Cell status: CALCEDMBR\n");
}
if (ulCellStatus & ESS_MDX_CELLSTATUS_READONLY)
{
printf("Cell status: READONLY\n");
}
}
}
if ((sts = EssMdxFreeQuery(hQry)) != ESS_STS_NOERR)
{
printf("EssMdxFreeQuery failure: %ld\n", sts);
exit ((int) sts);
}
printf("EssMdxFreeQuery sts: %ld\n", sts);
}
void ESS_Term()
{
ESS_STS_T sts = ESS_STS_NOERR;
if ((sts = EssTerm(hInst)) != ESS_STS_NOERR)
{
/* error terminating API */
exit((ESS_USHORT_T) sts);
}
printf("EssTerm sts: %ld\n", sts);
}
void ESS_Logout()
{
ESS_STS_T sts = ESS_STS_NOERR;
sts = EssLogout(hCtx);
printf("\n\nEssLogout sts: %ld\n",sts);
}
void ESS_SetActive()
{
ESS_STS_T sts = ESS_STS_NOERR;
ESS_ACCESS_T Access;
sts = EssSetActive(hCtx, AppName, DbName, &Access);
printf("EssSetActive sts: %ld\n",sts);
}
int main(int argc, char *argv[])
{
FILE *f;
char *s, *sout;
int n, l, e;
assert(argc > 1);
f = fopen(argv[1], "r");
assert(f != NULL);
s = qry;
n = MAXQRYLEN;
while (n > 0 && !feof(f) && fgets(s, n, f) != NULL)
{
l = strlen(s);
s += l;
n -= l;
}
if ((e = ferror(f)) != 0)
{
printf("fgets error %d\n", e);
exit((int) e);
}
fclose(f);
printf("The query is\n%s\n", qry);
if (argc > 2)
{
AppName = argv[2];
}
if (argc > 3)
{
DbName = argv[3];
}
ESS_Init();
ESS_Login();
ESS_SetActive();
ESS_MdxQry();
ESS_Logout();
ESS_Term();
return 0;
}