C:/cygwin/home/shubhrab/FM/CEP/esp/dev/r5/main/src/cpp/include/public/interfaces/sdk/esp_stream.h

#ifndef __ESP_STREAM_H
#define __ESP_STREAM_H

#include <sdk/esp_types.h>

#ifdef __cplusplus
extern "C" {
#endif

#define ESP_DATATYPE_INTEGER    1   
#define ESP_DATATYPE_LONG       2   
#define ESP_DATATYPE_FLOAT      3   
#define ESP_DATATYPE_DATE       4   
#define ESP_DATATYPE_STRING     5   
#define ESP_DATATYPE_NULL       6   
#define ESP_DATATYPE_MONEY      7   
#define ESP_DATATYPE_TIMESTAMP  8   
#define ESP_DATATYPE_OBJECT     9   
#define ESP_DATATYPE_BOOLEAN   10   
#define ESP_DATATYPE_MONEY01   11   
#define ESP_DATATYPE_MONEY02   12   
#define ESP_DATATYPE_MONEY03   13   
#define ESP_DATATYPE_MONEY04   14   
#define ESP_DATATYPE_MONEY05   15   
#define ESP_DATATYPE_MONEY06   16   
#define ESP_DATATYPE_MONEY07   17   
#define ESP_DATATYPE_MONEY08   18   
#define ESP_DATATYPE_MONEY09   19   
#define ESP_DATATYPE_MONEY10   20   
#define ESP_DATATYPE_MONEY11   21   
#define ESP_DATATYPE_MONEY12   22   
#define ESP_DATATYPE_MONEY13   23   
#define ESP_DATATYPE_MONEY14   24   
#define ESP_DATATYPE_MONEY15   25   
#define ESP_DATATYPE_INTERVAL  26   
#define ESP_DATATYPE_BIGDATETIME 27 
#define ESP_DATATYPE_BINARY    28   
typedef enum {
    ESP_INTEGER    =  1,    
    ESP_LONG       =  2,    
    ESP_FLOAT      =  3,    
    ESP_DATE       =  4,    
    ESP_STRING     =  5,    
    ESP_NULL       =  6,    
    ESP_MONEY      =  7,    
    ESP_TIMESTAMP  =  8,    
    ESP_OBJECT     =  9,    
    ESP_BOOLEAN    = 10,    
    ESP_MONEY01    = 11,    
    ESP_MONEY02    = 12,    
    ESP_MONEY03    = 13,    
    ESP_MONEY04    = 14,    
    ESP_MONEY05    = 15,    
    ESP_MONEY06    = 16,    
    ESP_MONEY07    = 17,    
    ESP_MONEY08    = 18,    
    ESP_MONEY09    = 19,    
    ESP_MONEY10    = 20,    
    ESP_MONEY11    = 21,    
    ESP_MONEY12    = 22,    
    ESP_MONEY13    = 23,    
    ESP_MONEY14    = 24,    
    ESP_MONEY15    = 25,    
    ESP_INTERVAL   = 26,    
    ESP_BIGDATETIME= 27,    
    ESP_BINARY     = 28,    
}
ESP_DATA_T;

typedef enum
{
    ESP_STREAM_OP_NOOP =   0,       
    ESP_STREAM_OP_INSERT = 1,       
    ESP_STREAM_OP_UPDATE = 3,       
    ESP_STREAM_OP_DELETE = 5,       
    ESP_STREAM_OP_UPSERT = 7,       
    ESP_STREAM_OP_SAFEDELETE = 13   
}
ESP_OPERATION_T;

typedef enum
{
    SOURCE,                 
    DERIVED,                
    ESP_STREAM_SQL_QUERY,   
    ESP_STREAM_DELTA,       
    ESP_STREAM_SIMPLE,      
    ESP_STREAM_WINDOW,      
    ESP_STREAM_SYSTEM,      
    ESP_STREAM_ERROR,       
    ESP_STREAM_LEGACY       
}
ESP_STREAM_TYPE_T;

typedef enum
{
    ESP_STREAM_INPUT,          
    ESP_STREAM_OUTPUT,         
    ESP_STREAM_LOCAL           
}
ESP_STREAM_VISIBILITY_T;
ESPAPICALL int32_t esp_schema_get_numcolumns(
        const EspSchema * schema,           
        int32_t * numcolumns,               
        EspError * error);

ESPAPICALL const char * esp_schema_get_column_name(
        const EspSchema * schema,           
        const int32_t column_no,            
        EspError * error);

ESPAPICALL int32_t esp_schema_get_column_type(
        const EspSchema * schema,           
        const int32_t column_no,            
        int32_t * type,                     
        EspError * error);

ESPAPICALL int32_t esp_schema_get_column_type_by_name(
        const EspSchema * schema,           
        const char * column_name,           
        int32_t * type,                     
        EspError * error);

ESPAPICALL int32_t esp_schema_is_keycolumn(
        const EspSchema * schema,           
        const int32_t column_no,            
        int32_t * key,                      
        EspError * error);


ESPAPICALL int32_t esp_stream_get_type(
        const EspStream * stream,                   
        ESP_STREAM_TYPE_T * type,                   
        EspError * error);

ESPAPICALL int32_t esp_stream_get_visibility(
        const EspStream * stream,                   
        ESP_STREAM_VISIBILITY_T * visibility,       
        EspError * error);

ESPAPICALL int32_t esp_stream_get_id(
        const EspStream * stream,                   
        int32_t * id,                               
        EspError * error);

ESPAPICALL const char * esp_stream_get_name(
        const EspStream * stream,                   
        EspError * error);

ESPAPICALL const EspSchema * esp_stream_get_schema(
        const EspStream * stream,                   
        EspError * error);

ESPAPICALL int32_t esp_data_binary_from_hexstring(
        const char * hexstring,     
        uint8_t * binary_data,      
        uint32_t * buffsize,        
        EspError * error);          
ESPAPICALL int32_t esp_data_hexstring_from_binary(
        const uint8_t * binary_data,    
        const uint32_t data_size,       
        char * hexstring,               
        uint32_t * buffsize,            
        EspError * error);              
ESPAPICALL EspMoney * esp_money_create(
        EspError * error);

ESPAPICALL EspMoney * esp_money_create_string(
        const char * string_value,      
        EspError * error);              
ESPAPICALL EspMoney * esp_money_create_long(
        const int64_t long_value,           
        const uint32_t precision,           
        EspError * error);

ESPAPICALL EspMoney * esp_money_as_precision(
        const EspMoney * money,         
        const uint32_t precision,       
        EspError * error);              
ESPAPICALL int32_t esp_money_free(
        EspMoney * money,               
        EspError * error);

ESPAPICALL int32_t esp_money_get_long(
        const EspMoney * money,         
        int64_t * long_value,           
        EspError * error);

ESPAPICALL int32_t esp_money_get_precision(
        const EspMoney * money,         
        uint32_t * precision,           
        EspError * error);

ESPAPICALL int32_t esp_money_get_factor(
        const EspMoney * money,         
        uint64_t * factor,              
        EspError * error);


ESPAPICALL EspBigDatetime * esp_bigdatetime_create(
        EspError * error);

ESPAPICALL EspBigDatetime * esp_bigdatetime_create_string(
        const char * string_value,
        EspError * error);

ESPAPICALL EspBigDatetime * esp_bigdatetime_create_microseconds(
        const int64_t microseconds,
        EspError * error);

ESPAPICALL int32_t esp_bigdatetime_free(
        EspBigDatetime * datetime,
        EspError * error);

ESPAPICALL int32_t esp_bigdatetime_get_microseconds(
        const EspBigDatetime * datetime,
        int64_t * microseconds,
        EspError * error);

#ifdef __cplusplus
}
#endif

#endif /* __ESP_STREAM_H */