/**** Global functions definitions. ****/
ErrorNumber allocLib( TA_UDBase **uDBasePtr )
{
TA_InitializeParam initializeParam;
TA_RetCode retCode;
TA_UDBase *uDBase;
/* Initialize the library. */
memset( &initializeParam, 0, sizeof( TA_InitializeParam ) );
initializeParam.logOutput = stdout;
retCode = TA_Initialize( &initializeParam );
if( retCode != TA_SUCCESS )
{
printf( "TA_Initialize failed [%d]\n", retCode );
return TA_TESTUTIL_INIT_FAILED;
}
/* Install a fatal error handler. */
retCode = TA_SetFatalErrorHandler( myFatalHandler );
if( retCode != TA_SUCCESS )
{
printf( "TA_SetFatalErrorHandler failed [%d]\n", retCode );
TA_Shutdown();
return TA_TESTUTIL_SET_FATAL_ERROR_FAILED;
}
/* Create an unified database. */
retCode = TA_UDBaseAlloc( &uDBase );
if( retCode != TA_SUCCESS )
{
printf( "TA_UDBaseAlloc failed [%d]\n", retCode );
TA_Shutdown();
return TA_TESTUTIL_UDBASE_ALLOC_FAILED;
}
*uDBasePtr = uDBase;
return TA_TEST_PASS;
}
ErrorNumber freeLib( TA_UDBase *uDBase )
{
TA_RetCode retCode;
/* For testing purpose */
/* TA_FATAL_RET( "Test again", 100, 200, 0 ); */
retCode = TA_UDBaseFree( uDBase );
if( retCode != TA_SUCCESS )
{
printf( "TA_UDBaseFree failed [%d]\n", retCode );
return TA_TESTUTIL_UDBASE_FREE_FAILED;
}
retCode = TA_Shutdown();
if( retCode != TA_SUCCESS )
{
printf( "TA_Shutdown failed [%d]\n", retCode );
return TA_TESTUTIL_SHUTDOWN_FAILED;
}
return TA_TEST_PASS;
}
int main( int argc, char **argv )
{
TA_RetCode retCode;
int retValue;
/* Verify the parameters. */
if( argc != 2 )
{
print_usage( "Bad Parameter" );
return -1;
}
/* Initialize TA-LIB. */
retCode = TA_Initialize( NULL );
if( retCode != TA_SUCCESS )
{
print_error( retCode );
return -1;
}
/* Fetch and display the WebPage. */
retCode = TA_WebFetch( argv[1], stdout );
if( retCode != TA_SUCCESS )
{
print_error( retCode );
retValue = -1;
}
else
retValue = 0;
/* Clean-up and exit. */
TA_Shutdown();
return retValue;
}
TALIB::~TALIB ()
{
TA_Shutdown();
}
Datum ta_f( PG_FUNCTION_ARGS)
{
// Declare for TA
TA_RetCode retCode;
TA_Real *closePrice = NULL;
TA_Real *out;
TA_Integer outBeg;
TA_Integer outNbElement;
// Declare for postgres
FuncCallContext *funcctx;
int call_cntr;
int max_calls;
Datum *result = NULL;
int dim;
int z;
ArrayType *ur = PG_GETARG_ARRAYTYPE_P(0);
if (array_contains_nulls(ur))
{
ereport(ERROR,
( errcode(ERRCODE_ARRAY_ELEMENT_ERROR), errmsg("cannot work with arrays containing NULLs") ));
}
dim = ARRNELEMS(ur);
closePrice = ARRPTR(ur);
if (SRF_IS_FIRSTCALL())
{
MemoryContext oldcontext;
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* One-time setup code appears here: */
retCode = TA_Initialize();
if (retCode != TA_SUCCESS)
{
ereport(ERROR,
( errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Cannot initialize TA-Lib (%d)!\n", retCode) ));
}
out = palloc(dim * sizeof(TA_Real));
retCode = TA_MA(0, dim - 1, &closePrice[0], 5, TA_MAType_SMA, &outBeg,
&outNbElement, &out[0]);
result = palloc(outNbElement * sizeof(Datum));
// Error log for debugging
/*
ereport(NOTICE,
(errmsg("dims %d, outBeg: %d, outNbElement %d\n", dim, outBeg, outNbElement)));
*/
for (z = 0; z < dim; z++)
{
// Error log for debugging
//ereport(NOTICE, (errmsg("z: %d, out[z]: %5.1f", z, out[z])));
if(z > outBeg-1) {
result[z] = Float8GetDatum(out[z-outBeg]);
continue;
}
result[z] = NULL;
}
TA_Shutdown();
funcctx->max_calls = dim;
funcctx->user_fctx = result;
MemoryContextSwitchTo(oldcontext);
}
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
if (call_cntr < max_calls)
{
if(((Datum *) funcctx->user_fctx)[call_cntr]) {
SRF_RETURN_NEXT(funcctx, ((Datum *) funcctx->user_fctx)[call_cntr]);
}
SRF_RETURN_NEXT_NULL(funcctx);
}
SRF_RETURN_DONE(funcctx);
}
static ErrorNumber testHistoryAlloc( void )
{
TA_UDBase *unifiedDatabase;
TA_History *data;
TA_RetCode retCode;
TA_InitializeParam param;
TA_AddDataSourceParam addParam;
TA_HistoryAllocParam histParam;
memset( ¶m, 0, sizeof( TA_InitializeParam ) );
param.logOutput = stdout;
retCode = TA_Initialize( ¶m );
if( retCode != TA_SUCCESS )
{
printf( "Cannot initialize TA-LIB (%d)!", retCode );
return TA_REGTEST_HISTORYALLOC_0;
}
/* Create an unified database. */
if( TA_UDBaseAlloc( &unifiedDatabase ) != TA_SUCCESS )
{
TA_Shutdown();
return TA_REGTEST_HISTORYALLOC_1;
}
/* USE SIMULATOR DATA */
memset( &addParam, 0, sizeof( TA_AddDataSourceParam ) );
addParam.id = TA_SIMULATOR;
addParam.flags = TA_NO_FLAGS;
retCode = TA_AddDataSource( unifiedDatabase, &addParam );
/* Now, display all daily close price available
* for the DAILY_REF_0 symbol.
*/
if( retCode != TA_SUCCESS )
return TA_REGTEST_ADDDSOURCE_FAILED;
#if defined __BORLANDC__
#pragma warn -ccc
#pragma warn -rch
#endif
#define CHECK_FIELDSUBSET(field_par) \
{ \
memset( &histParam, 0, sizeof( TA_HistoryAllocParam ) ); \
histParam.category = "TA_SIM_REF"; \
histParam.symbol = "DAILY_REF_0"; \
histParam.field = field_par; \
histParam.period = TA_DAILY; \
retCode = TA_HistoryAlloc( unifiedDatabase, &histParam, &data ); \
if( retCode == TA_SUCCESS ) \
{ \
if( (field_par) & TA_OPEN ) \
{ \
if( !data->open ) \
return TA_REGTEST_HISTORYALLOC_2; \
if( data->open[0] != 92.5 ) \
return TA_REGTEST_HISTORYALLOC_3; \
} \
else \
{ \
if( data->open ) \
return TA_REGTEST_HISTORYALLOC_4; \
} \
if( (field_par) & TA_HIGH ) \
{ \
if( !data->high ) \
return TA_REGTEST_HISTORYALLOC_5; \
if( data->high[0] != 93.25 ) \
return TA_REGTEST_HISTORYALLOC_6; \
} \
else \
{ \
if( data->high ) \
return TA_REGTEST_HISTORYALLOC_7; \
} \
if( (field_par) & TA_LOW ) \
{ \
if( !data->low ) \
return TA_REGTEST_HISTORYALLOC_8; \
if( data->low[0] != 90.75 ) \
return TA_REGTEST_HISTORYALLOC_9; \
} \
else \
{ \
if( data->low ) \
return TA_REGTEST_HISTORYALLOC_10; \
} \
if( (field_par) & TA_CLOSE ) \
{ \
if( !data->close ) \
return TA_REGTEST_HISTORYALLOC_11; \
if( data->close[0] != 91.50 ) \
return TA_REGTEST_HISTORYALLOC_12; \
} \
else \
{ \
if( data->close ) \
return TA_REGTEST_HISTORYALLOC_13; \
} \
if( (field_par) & TA_VOLUME ) \
{ \
if( !data->volume ) \
return TA_REGTEST_HISTORYALLOC_14; \
if( data->volume[0] != 4077500) \
return TA_REGTEST_HISTORYALLOC_15; \
} \
else \
{ \
if( data->volume ) \
return TA_REGTEST_HISTORYALLOC_16; \
} \
if( (field_par) & TA_TIMESTAMP ) \
{ \
if( !data->timestamp ) \
return TA_REGTEST_HISTORYALLOC_17; \
} \
else \
{ \
if( data->timestamp ) \
return TA_REGTEST_HISTORYALLOC_18; \
} \
TA_HistoryFree( data ); \
} \
else \
{ \
printf( "Cannot TA_HistoryAlloc for TA_SIM_REF (%d)!\n", retCode ); \
return TA_REGTEST_HISTORYALLOC_19; \
} \
}
/* 6 Fields */
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME)
/* 5 Fields */
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH|TA_VOLUME)
/* 4 Fields */
CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE|TA_HIGH)
/* 3 Fields */
CHECK_FIELDSUBSET(TA_HIGH|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_CLOSE|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_CLOSE|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_OPEN|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_LOW)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE|TA_HIGH)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_HIGH)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_CLOSE)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_CLOSE)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW|TA_CLOSE)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE|TA_VOLUME)
/* Two field. */
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_OPEN)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_HIGH)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_LOW)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_CLOSE)
CHECK_FIELDSUBSET(TA_TIMESTAMP|TA_VOLUME)
CHECK_FIELDSUBSET(TA_OPEN|TA_HIGH)
CHECK_FIELDSUBSET(TA_OPEN|TA_LOW)
CHECK_FIELDSUBSET(TA_OPEN|TA_CLOSE)
CHECK_FIELDSUBSET(TA_OPEN|TA_VOLUME)
CHECK_FIELDSUBSET(TA_HIGH|TA_LOW)
CHECK_FIELDSUBSET(TA_HIGH|TA_CLOSE)
CHECK_FIELDSUBSET(TA_HIGH|TA_VOLUME)
CHECK_FIELDSUBSET(TA_LOW|TA_CLOSE)
CHECK_FIELDSUBSET(TA_LOW|TA_VOLUME)
CHECK_FIELDSUBSET(TA_CLOSE|TA_VOLUME)
/* One Field */
CHECK_FIELDSUBSET(TA_TIMESTAMP);
CHECK_FIELDSUBSET(TA_OPEN);
CHECK_FIELDSUBSET(TA_HIGH)
CHECK_FIELDSUBSET(TA_LOW)
CHECK_FIELDSUBSET(TA_CLOSE)
CHECK_FIELDSUBSET(TA_VOLUME)
#undef CHECK_FIELDSUBSET
/* Clean-up and exit. */
TA_UDBaseFree( unifiedDatabase );
TA_Shutdown();
return TA_SUCCESS;
}
TA_RetCode TA_Initialize( const TA_InitializeParam *param )
{
/* Note: Keep that function simple.
* No tracing, no stdio and no assert.
*/
TA_RetCode retCode;
#if !defined( TA_SINGLE_THREAD )
unsigned int again; /* Boolean */
unsigned int i;
#endif
/* Allocate the "global variable" used to manage the global
* variables of all other modules...
*/
memset( TA_Globals, 0, sizeof( TA_LibcPriv ) );
TA_Globals->magicNb = TA_LIBC_PRIV_MAGIC_NB;
if( param )
{
if( param->logOutput )
{
/* Override someone intention to use stdin!? */
if( param->logOutput == stdin )
TA_Globals->stdioFile = stdout;
else
TA_Globals->stdioFile = param->logOutput;
TA_Globals->stdioEnabled = 1;
}
if( param->userLocalDrive )
TA_Globals->localCachePath = param->userLocalDrive;
}
#if !defined( TA_SINGLE_THREAD )
/* For multithread, allocate all semaphores
* protecting the module's globals.
*/
again = 1;
for( i=0; i < TA_NB_GLOBAL_ID && again; i++ )
{
retCode = TA_SemaInit( &(TA_Globals->moduleControl[i].sema), 1 );
if( retCode != TA_SUCCESS )
again = 0;
}
if( again == 0 )
{
/* Clean-up and exit. */
for( i=0; i < TA_NB_GLOBAL_ID; i++ )
TA_SemaDestroy( &(TA_Globals->moduleControl[i].sema) );
memset( TA_Globals, 0, sizeof( TA_LibcPriv ) );
return TA_INTERNAL_ERROR(4);
}
#endif
/* Force immediatly the initialization of the memory module.
* Note: No call to the tracing capability are allowed in TA_MemInit.
*/
retCode = TA_MemInit( sizeof( TA_LibcPriv ) );
/* Force immediatly the initialization of the tracing module. */
if( retCode == TA_SUCCESS )
retCode = TA_TraceInit();
if( retCode != TA_SUCCESS )
{
/* Clean-up and exit. */
#if !defined( TA_SINGLE_THREAD )
for( i=0; i < TA_NB_GLOBAL_ID; i++ )
TA_SemaDestroy( &(TA_Globals->moduleControl[i].sema) );
#endif
memset( TA_Globals, 0, sizeof( TA_LibcPriv ) );
return TA_INTERNAL_ERROR(5);
}
/* Tracing can now be safely used by the memory module until
* shutdown in TA_Shutdown.
*/
TA_Globals->traceEnabled = 1;
/*** At this point, TA_Shutdown can be called to clean-up. ***/
/* Allocate the default string cache used throughout the library. */
retCode = TA_StringCacheAlloc( &(TA_Globals->dfltCache) );
if( retCode != TA_SUCCESS )
{
TA_Shutdown();
return retCode;
}
return TA_SUCCESS;
}
