struct skynet_module *
skynet_module_query(const char * name) {
struct skynet_module * result = _query(name);
if (result)
return result;
SPIN_LOCK(M)
result = _query(name); // double check
if (result == NULL && M->count < MAX_MODULE_TYPE) {
int index = M->count;
void * dl = _try_open(M,name);
if (dl) {
M->m[index].name = name;
M->m[index].module = dl;
if (_open_sym(&M->m[index]) == 0) {
M->m[index].name = skynet_strdup(name);
M->count ++;
result = &M->m[index];
}
}
}
SPIN_UNLOCK(M)
return result;
}
struct skynet_module *
skynet_module_query(const char * name) {
struct skynet_module * result = _query(name);
if (result)
return result;
while(__sync_lock_test_and_set(&M->lock,1)) {}
result = _query(name); // double check
if (result == NULL && M->count < MAX_MODULE_TYPE) {
int index = M->count;
void * dl = _try_open(M,name);
if (dl) {
M->m[index].name = name;
M->m[index].module = dl;
if (_open_sym(&M->m[index])== 0) {
M->m[index].name = strdup(name);
M->count ++;
result = &M->m[index];
}
}
}
__sync_lock_release(&M->lock);
return result;
}
int _query(int a,int b,int k,int l, int r){
if(r<=a||b<=l)return INT_MAX;
if(a<=l&&r<=b)return val[k];
else{
int vl=_query(a,b,k*2+1,l,(l+r)/2);
int vr=_query(a,b,k*2+2,(l+r)/2,r);
return min(vl,vr);
}
}
/**
* Returns nonzero if the given optin object has an option by the given name, zero otherwise
*/
int optin_has_option(optin* o, const char* name) {
if (!o) {
return 0;
}
return _query(o->options, name) != 0;
}
/**
* Looks up an option in the option dictionary by the given name. Creates a new option and adds it to
* the options dictionary if not found
*/
static _option* _query_or_new(hashtable* options, const char* name) {
_option_wrapper* option_wrapper;
_option* option;
option = _query(options, name);
if (!option) {
/* Not found, create and insert */
option = (_option*)malloc(sizeof(_option));
memset(option, 0, sizeof(_option));
option->name = xp_strdup(name);
/* Key by the long name */
option_wrapper = (_option_wrapper*)malloc(sizeof(_option_wrapper));
memset(option_wrapper, 0, sizeof(_option_wrapper));
option_wrapper->key = xp_strdup(name);
option_wrapper->alias = 0; /* We own the option */
option_wrapper->o = option;
ht_insert(options, (void*)option_wrapper);
/* Key by the short name */
_set_shortname(options, name, name[0]);
}
return option;
}
/**
* Sets the one-character shortname of the given option
*
* options - The options dictionary which contains the option
* name - The (full) name of the option
* shortname - The one-character short name of the option
*
* NOTES:
* - It is not necessary to call this function unless you wish to override the default short name, which
* is the first letter of the long name
* - If an existing short name exists (including the default), it will be removed and replaced
* - If an identical short name exists, it will be replaced with this one, even if it is for a different
* option
*/
void _set_shortname(hashtable* options, const char* name, char shortname) {
_option* option;
_option_wrapper* wrapper, *query_wrapper;
char* str_shortname;
if (!options) {
return;
}
option = _query(options, name);
if (!option) {
return;
}
xp_asprintf(&str_shortname, "%c", shortname);
wrapper = (_option_wrapper*)malloc(sizeof(_option_wrapper));
wrapper->key = str_shortname;
wrapper->alias = 1; /* We don't own the option */
query_wrapper = wrapper;
if (ht_lookup(options, (void*)&wrapper) != 0) {
/* It's not in there, just add it */
wrapper->key = xp_strdup(str_shortname);
ht_insert(options, (void*)wrapper);
} else {
/* Already in there */
free(query_wrapper->key);
free(query_wrapper);
}
wrapper->o = option;
}
int
init(
boost::shared_ptr<cql::cql_session_t> session,
int n,
cql::cql_consistency_enum cl,
bool batch)
{
std::string query_string = str(boost::format("INSERT INTO %s(k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE);
if(batch)
{
std::string bth;
bth.append("BEGIN BATCH ");
bth.append(str(boost::format("INSERT INTO %s(k, i) VALUES (0, 0)") % test_utils::SIMPLE_TABLE));
bth.append(" APPLY BATCH");
query_string = bth;
}
for (int i = 0; i < n; ++i)
{
boost::shared_ptr<cql::cql_query_t> _query(
new cql::cql_query_t(query_string ,cl));
boost::shared_future<cql::cql_future_result_t> query_future = session->query(_query);
query_future.wait();
cql::cql_future_result_t query_result = query_future.get();
if(query_result.error.code != 0)
return query_result.error.code;
}
return 0;
}
varargs mixed query(string prop, int raw) {
mixed data, pdata;
if(!mapp(dbase)) {
return 0;
}
if(undefinedp(dbase[prop]) && (strsrch(prop, '/')!=-1)) {
data = _query(dbase, explode(prop, "/"));
} else {
data = dbase[prop];
}
if(default_ob) {
if(undefinedp(data)) {
data = default_ob->query(prop, 1);
} else if(mapp(data)) {
pdata = default_ob->query(prop, 1);
if(mapp(pdata)) {
data = pdata + data;
}
}
}
if(raw) {
return data;
}
return evaluate( data, this_object() );
}
void L2Socket::Acceptor( CChar _ip, CChar _port )
{
if ( ioService == nullptr ) ioService = new io_service();
if ( acceptor != nullptr ) delete acceptor;
//LOG( "Acceptor ip: "+_ip+" port: "+_port);
tcp::resolver _resolver(*ioService);
// tcp::v4() = 127.0.0.1
// ip::host_name()
//address_v4 address = address_v4::from_string(_ip);
//tcp::endpoint endpoint(address, *_port);
tcp::resolver::query _query( _ip, _port);
tcp::endpoint endpoint = *_resolver.resolve(_query);
//LOG( "Acceptor ip: "+_ip+" port: "+endpoint.port());
//LOG( "Acceptor ip: "+address.to_string()+" port: "+endpoint.port());
acceptor = new tcp::acceptor(*ioService,endpoint);
//acceptor = new tcp::acceptor(*ioService);
//acceptor->open(endpoint.protocol());
//acceptor->set_option(socket_base::reuse_address(config.reuse_address));
//acceptor->bind(endpoint);
//acceptor->listen();
if(acceptor != nullptr )
LOG( "Acceptor ip: "+endpoint.address().to_string()+" port: "+endpoint.port());
else
LOG( "Acceptor acceptor nullptr!!!" );
OnAccept();
}
static JSVAL query(JSARGS args) {
redisContext *c = (redisContext *)JSOPAQUE(args[0]);
String::Utf8Value _query(args[1]->ToString());
redisReply *reply = (redisReply *)redisCommand(c, *_query);
switch (reply->type) {
case REDIS_REPLY_STATUS:
case REDIS_REPLY_STRING:
{
Handle<String> s = String::New(reply->str, reply->len);
freeReplyObject(reply);
return s;
}
case REDIS_REPLY_ARRAY:
{
Handle<Array> a = Array::New();
int ndx = 0;
for (int j=0; j<reply->elements; j++) {
redisReply *element = reply->element[j];
switch (element->type) {
case REDIS_REPLY_STATUS:
case REDIS_REPLY_STRING:
a->Set(ndx++, String::New(element->str, element->len));
break;
case REDIS_REPLY_INTEGER:
a->Set(ndx++, Number::New(element->integer));
break;
case REDIS_REPLY_NIL:
a->Set(ndx++, Null());
break;
case REDIS_REPLY_ERROR:
{
Handle<String>s = String::New(reply->str, reply->len);
freeReplyObject(reply);
return ThrowException(String::Concat(String::New("Redis query error: "), s));
}
}
}
freeReplyObject(reply);
return a;
}
case REDIS_REPLY_INTEGER:
{
Handle<Number>n = Number::New(reply->integer);
freeReplyObject(reply);
return n;
}
case REDIS_REPLY_NIL:
freeReplyObject(reply);
return Null();
case REDIS_REPLY_ERROR:
{
Handle<String>s = String::New(reply->str, reply->len);
freeReplyObject(reply);
return ThrowException(String::Concat(String::New("Redis query error: "), s));
}
}
}
int YARPNameClient::query (const YARPString &s, ACE_INET_Addr &addr, int *type)
{
YNC("YNC %s:%d --> query %s\n",__FILE__,__LINE__,s.c_str());
int ret = YARP_FAIL;
mutex_.Wait();
ret = _query(s, addr, type);
mutex_.Post();
return ret;
}
void L2Socket::ConnectHTTP( size_t _agentOID, CChar _http, CChar _port )
{
if ( ioService == nullptr ) ioService = new io_service();
tcp::socket* _socket = new tcp::socket(*ioService);
tcp::resolver _resolver(*ioService);
tcp::resolver::query _query(_http, _port);
LOG( "ConnectHttp start resolve...");
_resolver.async_resolve(_query, bind(&L2Socket::HandleResolve,this,ref(*_socket),_agentOID,_1,_2));
}
void moduleInsert(struct module* mod) {
while(__sync_lock_test_and_set(&M->lock, 1)) {}
struct module* m = _query(mod->name);
assert(m == NULL && M->count < MAX_MODULE_TYPE);
int index = M->count;
M->m[index] = *mod;
++M->count;
__sync_lock_release(&M->lock);
}
/**
* Returns nonzero if the given option is present and was explicitly set by the user, zero if no
* such option exists or if the option was not explcitly set by the user
*/
int optin_option_is_set(optin* o, const char* name) {
_option* option;
if (!o) {
return 0;
}
option = _query(o->options, name);
return option && option->set;
}
void L2Socket::ConnectIP( size_t _agentOID, CChar _ip, CChar _port )
{
if ( ioService == nullptr ) ioService = new io_service();
tcp::socket* _socket = new tcp::socket(*ioService);
tcp::resolver _resolver(*ioService);
tcp::resolver::query _query(_ip, _port);
tcp::resolver::iterator _it = _resolver.resolve(_query);
LOG( "ConnectIP start..." );
async_connect(*_socket,_it,bind(&L2Socket::HandleConnect,this,ref(*_socket),_agentOID,_1,_2));
}
static JSVAL command(JSARGS args) {
redisContext *c = (redisContext *)JSOPAQUE(args[0]);
String::Utf8Value _query(args[1]->ToString());
char *argstr = strdup(*_query);
char *in = argstr;
int n = 0;
while (*in) {
while (isspace(*in)) in++;
if (*in) {
n++;
if (*in == '"') {
in++;
while (*in && *in != '"') in++;
if (*in == '"') in++;
}
else {
while (*in && !isspace(*in)) in++;
}
}
}
in = argstr;
int argc = n;
char *argv[n];
n = 0;
while (*in) {
while (isspace(*in)) in++;
if (*in) {
if (*in == '"') {
in++;
argv[n++] = in;
while (*in && *in != '"') in++;
if (*in == '"') {
*in = '\0';
in++;
}
}
else {
argv[n++] = in;
while (*in && !isspace(*in)) {
in++;
}
if (*in != '\0') {
*in++ = '\0';
}
}
}
}
// printf("%s\n", *_query);
// redisReply *reply = (redisReply *)redisCommand(c, *_query);
redisReply *reply = (redisReply *)redisCommandArgv(c, argc, (const char **)argv, NULL);
free(argstr);
return Opaque::New(reply);
}
KRecord MySQLKDataDriver::
getKRecord(const string& market, const string& code,
size_t pos, KQuery::KType kType) {
string func_name(" [MySQLKDataDriver::getKRecord]");
KRecord result;
if (!m_mysql) {
HKU_ERROR("Null m_mysql!" << func_name);
return result;
}
/*if (kType >= KQuery::INVALID_KTYPE ) {
HKU_WARN("ktype(" << kType << ") is invalid" << func_name);
return result;
}*/
MYSQL_RES *mysql_result;
MYSQL_ROW row;
string table(_getTableName(market, code, kType));
std::stringstream buf (std::stringstream::out);
buf << "select date, open, high, low, close, amount, count from "
<< table << " order by date limit " << pos << ", 1";
if (!_query(buf.str())) {
HKU_ERROR("mysql_query error! " << func_name);
return result;
}
mysql_result = mysql_store_result(m_mysql.get());
if (!mysql_result) {
HKU_ERROR("mysql_store_result error!" << func_name);
return result;
}
while ((row = mysql_fetch_row(mysql_result))) {
try {
hku_uint64 d = boost::lexical_cast<hku_uint64>(row[0]);
result.datetime = Datetime(d);
result.openPrice = boost::lexical_cast<price_t>(row[1]);
result.highPrice = boost::lexical_cast<price_t>(row[2]);
result.lowPrice = boost::lexical_cast<price_t>(row[3]);
result.closePrice = boost::lexical_cast<price_t>(row[4]);
result.transAmount = boost::lexical_cast<price_t>(row[5]);
result.transCount = boost::lexical_cast<price_t>(row[6]);
} catch (...) {
HKU_INFO("Error get record " << pos << " " << table << func_name);
result = Null<KRecord>();
}
}
mysql_free_result(mysql_result);
return result;
}
varargs mixed query_with_slash(string prop, int raw)
{
mixed data;
if( !mapp(dbase) ) return 0;
if( undefinedp(dbase[prop]) && (strsrch(prop, '.')!=-1) )
data = _query(dbase, explode(prop, "."));
else
data = dbase[prop];
if( undefinedp(data) && default_ob )
data = default_ob->query(prop, 1);
if( raw ) return data;
return evaluate( data, this_object() );
}
shared_ptr<IDbResult> IDbConnection::query(const String &sql)
{
try
{
return _query(sql);
}
catch(std::exception &e)
{
logError(sql, e);
throw(e);
return nullptr;
}
}
/**
* Sets the callback function for the given option so that a user-function is called whenever an option
* is set by the user
*
* o - The optin object to which to add the option
* name - The long name of the option (example "haswidth")
* callback - Pointer to a function of type optin_fn, which will be called if the given option appears
*
* NOTES:
* - Calling the function with a null optin object has no effect
* - If the option does not exist, this funciton has no effect
* - The function will NOT be called for the default value if the user did not explicitly include the option
* on the command line
*/
void optin_set_callback(optin* o, const char* name, optin_fn callback) {
_option* option;
if (!o) {
return;
}
option = _query(o->options, name);
if (!option) {
return;
}
option->callback - callback;
}
struct module *module_query(const char *name) {
struct module *module = _query(name);
if (module) return module;
spinlock_lock(&M.lock);
module = _query(name);
if (!module && M.count < MODULE_SIZE) {
void *dl = _module_open(name);
if (dl) {
module = &M.modules[M.count];
module->name = (char *)name;
module->dl = dl;
if (_module_sym(module) == 0) {
char *_name = (char *)pixel_alloc(0, strlen(name)+1);
strcpy(_name, name);
module->name = _name;
M.count++;
} else {
module = 0;
}
}
}
spinlock_unlock(&M.lock);
return module;
}
json_t *arbplf_trans_run(void *userdata, json_t *root, int *retcode)
{
json_t *j_out = NULL;
model_and_data_t m;
column_reduction_t r_site;
column_reduction_t r_edge;
column_reduction_t r_trans;
int *first_idx;
int *second_idx;
int result = 0;
first_idx = NULL;
second_idx = NULL;
model_and_data_init(m);
column_reduction_init(r_site);
column_reduction_init(r_edge);
column_reduction_init(r_trans);
if (userdata)
{
fprintf(stderr, "internal error: unexpected userdata\n");
result = -1;
goto finish;
}
result = _parse(m, r_site, r_edge, r_trans, &first_idx, &second_idx, root);
if (result) goto finish;
j_out = _query(m, r_site, r_edge, r_trans, first_idx, second_idx, &result);
if (result) goto finish;
finish:
*retcode = result;
model_and_data_clear(m);
column_reduction_clear(r_site);
column_reduction_clear(r_edge);
column_reduction_clear(r_trans);
flint_free(first_idx);
flint_free(second_idx);
flint_cleanup();
return j_out;
}
FOURD_RESULT* fourd_query(FOURD *cnx,const char *query)
{
FOURD_RESULT* result;
result=calloc(1,sizeof(FOURD_RESULT));
result->cnx=cnx;
if(_query(cnx,3,query,result,cnx->preferred_image_types)==0)
{
result->numRow=-1;
return result;
}
else
{
fourd_free_result(result);
return NULL;
}
}
size_t MySQLKDataDriver::
getCount(const string& market,
const string& code,
KQuery::KType kType) {
string func_name(" [MySQLKDataDriver::getCount]");
size_t result = 0;
if (!m_mysql) {
HKU_ERROR("Null m_mysql!" << func_name);
return result;
}
/*if (kType >= KQuery::INVALID_KTYPE ) {
HKU_WARN("ktype(" << kType << ") is invalid" << func_name);
return result;
}*/
MYSQL_RES *mysql_result;
MYSQL_ROW row;
string table(_getTableName(market, code, kType));
std::stringstream buf (std::stringstream::out);
buf << "select count(1) from " << table;
if (!_query(buf.str())) {
HKU_ERROR("mysql_query error! " << func_name);
return result;
}
mysql_result = mysql_store_result(m_mysql.get());
if (!mysql_result) {
HKU_ERROR("mysql_store_result error!" << func_name);
return result;
}
while ((row = mysql_fetch_row(mysql_result))) {
try {
result = boost::lexical_cast<size_t>(row[0]);
} catch (...) {
HKU_INFO("Error get record count of" << table << func_name);
result = 0;
}
}
mysql_free_result(mysql_result);
return result;
}
/**
* Processes the given option as if it had been given on the command line
*
* o - The optin object that contains the option
* opt - The long or short option name (e.g. "velocity" or "v"), do not include dashes
* value - The value that the option takes (e.g "35"). Pass NULL if the option takes no value
*
* RETURNS: zero if the option was processed successfully, nonzero if there was an error
*/
int optin_process_option(optin* o, const char* opt, const char* value) {
_option* option;
/*fprintf(stderr, "Processing option: %s, value: %s\n", opt, value);*/
option = _query(o->options, opt);
if (!option) {
fprintf(stderr, "Unrecognized option: %s\n", opt);
return OPTIN_ERR_INVALID_OPTION;
}
switch(option->type) {
case OPTION_FLAG:
if (option->value.intptr != 0) {
*option->value.intptr = 1;
}
break;
case OPTION_INT:
if (option->value.intptr != 0) {
*option->value.intptr = atoi(value);
}
break;
case OPTION_FLOAT:
if (option->value.floatptr != 0) {
*option->value.floatptr = atof(value);
}
break;
case OPTION_STRING:
if (option->value.stringptr != 0) {
*option->value.stringptr = xp_strdup(value);
}
break;
}
option->set = 1;
return 0;
}
int
query(
boost::shared_ptr<cql::cql_session_t> session,
int n,
cql::cql_consistency_enum cl)
{
for (int i = 0; i < n; ++i)
{
boost::shared_ptr<cql::cql_query_t> _query(
new cql::cql_query_t(str(boost::format("SELECT * FROM %s WHERE k = 0") % test_utils::SIMPLE_TABLE),cl));
boost::shared_future<cql::cql_future_result_t> query_future;
query_future = session->query(_query);
if (!(query_future.timed_wait(boost::posix_time::seconds(20)))) {
BOOST_FAIL("Query timed out");
}
try {
cql::cql_future_result_t query_result = query_future.get();
if (query_future.has_value()) {
std::cout << "Queried endpoint: " << query_result.client->endpoint().to_string() << std::endl;
add_coordinator(query_result.client->endpoint().address());
if(query_result.error.code != 0) {
return query_result.error.code;
}
}
}
catch (...) {
BOOST_MESSAGE("Response contains EXCEPTION");
throw;
}
}
return 0;
}
INT32 migExport::_exportCL( const CHAR *pCSName,
const CHAR *pCLName,
INT32 &total )
{
INT32 rc = SDB_OK ;
INT32 clTotal = 0 ;
bson obj ;
bson_init( &obj ) ;
_gCollection = 0 ;
_gCollectionSpace = 0 ;
rc = _getCS( pCSName ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection space, rc = %d",
rc ) ;
goto error ;
}
rc = _getCL( pCLName ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection, rc = %d",
rc ) ;
goto error ;
}
rc = _query() ;
if ( rc )
{
if ( SDB_DMS_EOC == rc )
{
rc = SDB_OK ;
goto done ;
}
else
{
PD_LOG ( PDERROR, "Failed to get record, rc = %d",
rc ) ;
goto error ;
}
}
while ( TRUE )
{
rc = sdbNext( _gCursor, &obj ) ;
if ( rc )
{
if ( SDB_DMS_EOC != rc )
{
PD_LOG ( PDERROR, "Failed to get collection list, rc = %d",
rc ) ;
goto error ;
}
else
{
rc = SDB_OK ;
goto done ;
}
}
rc = _writeRecord( &obj ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to write record to file, rc = %d",
rc ) ;
goto error ;
}
bson_destroy ( &obj ) ;
++clTotal ;
}
done:
total += clTotal ;
bson_destroy ( &obj ) ;
if ( _gCollection )
{
sdbReleaseCollection ( _gCollection ) ;
}
if ( _gCollectionSpace )
{
sdbReleaseCS ( _gCollectionSpace ) ;
}
_gCollection = 0 ;
_gCollectionSpace = 0 ;
PD_LOG ( PDEVENT, "%s.%s export record %d in file",pCSName, pCLName, clTotal ) ;
return rc ;
error:
goto done ;
}
M->count ++;
result = &M->m[index];
}
}
}
SPIN_UNLOCK(M)
return result;
}
void
skynet_module_insert(struct skynet_module *mod) {
SPIN_LOCK(M)
struct skynet_module * m = _query(mod->name);
assert(m == NULL && M->count < MAX_MODULE_TYPE);
int index = M->count;
M->m[index] = *mod;
++M->count;
SPIN_UNLOCK(M)
}
void *
skynet_module_instance_create(struct skynet_module *m) {
if (m->create) {
return m->create();
} else {
return (void *)(intptr_t)(~0);
}
int fourd_exec(FOURD *cnx,const char *query)
{
return _query(cnx,3,query,NULL,cnx->preferred_image_types);
}
INT32 expCLExporter::run( UINT64 &exportedCount, UINT64 &failCount )
{
INT32 rc = SDB_OK ;
sdbCursorHandle hCusor = SDB_INVALID_HANDLE ;
sdbCollectionHandle hCL = SDB_INVALID_HANDLE ;
const CHAR *buf = NULL ;
UINT32 size = 0 ;
rc = _query( hCL, hCusor ) ;
if ( SDB_OK != rc )
{
PD_LOG ( PDERROR, "Failed to query collection %s.%s, rc = %d",
_cl.csName.c_str(), _cl.clName.c_str(), rc );
goto error ;
}
rc = _out.open() ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to open output, rc = %d", rc ) ;
goto error ;
}
rc = _convertor.init() ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to init convertor, rc = %d", rc ) ;
goto error ;
}
rc = _convertor.head( buf, size ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to get head of convertor, rc = %d", rc ) ;
goto error ;
}
if ( size > 0 )
{
rc = _out.output( buf, size );
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to output the head, rc = %d", rc ) ;
goto error ;
}
buf = _options.delRecord().c_str() ;
size = (UINT32)_options.delRecord().size() ;
rc = _out.output( buf, size );
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to output the record delimiter, rc = %d",
rc ) ;
goto error ;
}
}
rc = _exportRecords( hCusor, exportedCount, failCount ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to export records, rc = %d", rc ) ;
goto error ;
}
rc = _convertor.tail( buf, size ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to get tail of convertor, rc = %d", rc ) ;
goto error ;
}
if ( size > 0 )
{
rc = _out.output( buf, size );
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to output the tail, rc = %d", rc ) ;
goto error ;
}
}
done :
_out.close() ;
if ( SDB_INVALID_HANDLE != hCL )
{
sdbReleaseCollection(hCL) ;
}
if ( SDB_INVALID_HANDLE != hCusor )
{
sdbCloseCursor(hCusor) ;
sdbReleaseCursor(hCusor) ;
}
return rc ;
error :
goto done ;
}
