自学教程：C++ DB_GET_PAYLOAD函数代码示例

int bdb_cmd_exec(db_res_t *res, db_cmd_t *cmd){	db_con_t *con;	bdb_cmd_t *bcmd;	bdb_con_t *bcon;	/* First things first: retrieve connection info from the currently active	 * connection and also mysql payload from the database command	 */	con = cmd->ctx->con[db_payload_idx];	bcmd = DB_GET_PAYLOAD(cmd);	bcon = DB_GET_PAYLOAD(con);	if((bcon->flags & BDB_CONNECTED) == 0) {		ERR("bdb: not connected/n");		return -1;	}	bcmd->next_flag = -1;	switch(cmd->type) {		case DB_DEL:		case DB_PUT:		case DB_UPD:			/* no result expected - cleanup */			DBG("bdb: query with no result./n");			break;		case DB_GET:			return bdb_query(cmd, bcmd);			break;		default:			/* result expected - no cleanup */			DBG("bdb: query with result./n");	}	return 0;}

int my_con_connect(db_con_t* con){	struct my_con* mcon;	struct my_uri* muri;		mcon = DB_GET_PAYLOAD(con);	muri = DB_GET_PAYLOAD(con->uri);		/* Do not reconnect already connected connections */	if (mcon->flags & MY_CONNECTED) return 0;	DBG("mysql: Connecting to %.*s:%.*s/n",		con->uri->scheme.len, ZSW(con->uri->scheme.s),		con->uri->body.len, ZSW(con->uri->body.s));	if (my_connect_to) {		if (mysql_options(mcon->con, MYSQL_OPT_CONNECT_TIMEOUT, 						  (char*)&my_connect_to))			WARN("mysql: failed to set MYSQL_OPT_CONNECT_TIMEOUT/n");	}#if MYSQL_VERSION_ID >= 40101 	if ((my_client_ver >= 50025) || 		((my_client_ver >= 40122) && 		 (my_client_ver < 50000))) {		if (my_send_to) {			if (mysql_options(mcon->con, MYSQL_OPT_WRITE_TIMEOUT , 							  (char*)&my_send_to))				WARN("mysql: failed to set MYSQL_OPT_WRITE_TIMEOUT/n");		}		if (my_recv_to){			if (mysql_options(mcon->con, MYSQL_OPT_READ_TIMEOUT , 							  (char*)&my_recv_to))				WARN("mysql: failed to set MYSQL_OPT_READ_TIMEOUT/n");		}	}#endif		if (!mysql_real_connect(mcon->con, muri->host, muri->username, 							muri->password, muri->database, muri->port, 0, 0)) {		LOG(L_ERR, "mysql: %s/n", mysql_error(mcon->con));		return -1;	}		DBG("mysql: Connection type is %s/n", mysql_get_host_info(mcon->con));	DBG("mysql: Protocol version is %d/n", mysql_get_proto_info(mcon->con));	DBG("mysql: Server version is %s/n", mysql_get_server_info(mcon->con));	mcon->flags |= MY_CONNECTED;	/* Increase the variable that keeps track of number of connects performed	 * on this connection. The mysql module uses the variable to determine	 * when a pre-compiled command needs to be uploaded to the server again.	 * If the number in the my_con structure is large than the number kept	 * in my_cmd then it means that we have to upload the command to the server	 * again because the connection was reconnected meanwhile.	 */	mcon->resets++;	return 0;}

int bdb_con_connect(db_con_t* con){	bdb_con_t *bcon;	bdb_uri_t *buri;	bcon = DB_GET_PAYLOAD(con);	buri = DB_GET_PAYLOAD(con->uri);	/* Do not reconnect already connected connections */	if (bcon->flags & BDB_CONNECTED) return 0;	DBG("bdb: Connecting to %s/n", buri->uri);	/* create BDB environment */	bcon->dbp = bdblib_get_db(&buri->path);	if(bcon->dbp == NULL)	{		ERR("bdb: error binding to DB %s/n", buri->uri);		return -1;	}	DBG("bdb: Successfully bound to %s/n", buri->uri);	bcon->flags |= BDB_CONNECTED;	return 0;}

int my_con_connect(db_con_t* con){	struct my_con* mcon;	struct my_uri* muri;		mcon = DB_GET_PAYLOAD(con);	muri = DB_GET_PAYLOAD(con->uri);		/* Do not reconnect already connected connections */	if (mcon->flags & MY_CONNECTED) return 0;	DBG("mysql: Connecting to %.*s:%.*s/n",		con->uri->scheme.len, ZSW(con->uri->scheme.s),		con->uri->body.len, ZSW(con->uri->body.s));	if (my_connect_to) {		if (mysql_options(mcon->con, MYSQL_OPT_CONNECT_TIMEOUT, 						  (char*)&my_connect_to))			WARN("mysql: failed to set MYSQL_OPT_CONNECT_TIMEOUT/n");	}#if MYSQL_VERSION_ID >= 40101 	if ((my_client_ver >= 50025) || 		((my_client_ver >= 40122) && 		 (my_client_ver < 50000))) {		if (my_send_to) {			if (mysql_options(mcon->con, MYSQL_OPT_WRITE_TIMEOUT , 							  (char*)&my_send_to))				WARN("mysql: failed to set MYSQL_OPT_WRITE_TIMEOUT/n");		}		if (my_recv_to){			if (mysql_options(mcon->con, MYSQL_OPT_READ_TIMEOUT , 							  (char*)&my_recv_to))				WARN("mysql: failed to set MYSQL_OPT_READ_TIMEOUT/n");		}	}#endif		if (!mysql_real_connect(mcon->con, muri->host, muri->username, 							muri->password, muri->database, muri->port, 0, 0)) {		LOG(L_ERR, "mysql: %s/n", mysql_error(mcon->con));		return -1;	}		DBG("mysql: Connection type is %s/n", mysql_get_host_info(mcon->con));	DBG("mysql: Protocol version is %d/n", mysql_get_proto_info(mcon->con));	DBG("mysql: Server version is %s/n", mysql_get_server_info(mcon->con));	mcon->flags |= MY_CONNECTED;	return 0;}

/** Verify field type compatibility. * This function verifies the types of all parameters of a database command * with the types of corresponding fields on the server to make sure that they * can be converted. * @param cmd A command structure whose parameters are to be checked. * @retval 0 on success. * @retval A negative number if at least one field type does not match. * @todo Store oid and length as part of pg_fld, instead of the arrays used *       as parameters to PQ functions */static int check_types(db_cmd_t* cmd) { 	struct pg_cmd* pcmd; 	struct pg_con* pcon;		pcmd = DB_GET_PAYLOAD(cmd);	/* FIXME: The function should take the connection as one of parameters */	pcon = DB_GET_PAYLOAD(cmd->ctx->con[db_payload_idx]);	if (pg_check_fld2pg(cmd->match, pcon->oid)) return -1;	if (pg_check_fld2pg(cmd->vals, pcon->oid)) return -1;	if (pg_check_pg2fld(cmd->result, pcon->oid)) return -1;	return 0;}

/** Compares two LDAP connection URIs. * This function is called whenever the database abstraction layer in * SER needs to compare to URIs with the ldap scheme. The function * compares hosts and port numbers of both URIs (host part comparison * is case insensitive). The URI comparison is mainly used to * by the connection pool to determine if a connection to a given * server already exists. **/static unsigned char ld_uri_cmp(db_uri_t* uri1, db_uri_t* uri2){	struct ld_uri* luri1, *luri2;	if (!uri1 || !uri2) return 0;	luri1 = DB_GET_PAYLOAD(uri1);	luri2 = DB_GET_PAYLOAD(uri2);	if (luri1->ldap_url->lud_port != luri2->ldap_url->lud_port) return 0;	if (cmpstr(luri1->ldap_url->lud_host,			   luri2->ldap_url->lud_host, strcasecmp))		return 0;	return 1;}

/** Creates parameter data structures for PQexecPrepared. * This function creates auxiliary data structures that will be used to pass * parameter value and types to PQexecPrepared.  The function only allocates * memory buffers and determines oids of parameters, actual values will be * assigned by another function at runtime. * @param cmd A command where the data strctures will be created.  * @retval 0 on success. * @retval A negative number on error. */static int create_pg_params(db_cmd_t* cmd){	int num;	struct pg_cmd* pcmd;	pcmd = DB_GET_PAYLOAD(cmd);	num = cmd->match_count + cmd->vals_count;	if (num == 0) return 0;	pcmd->params.val = (const char**)pkg_malloc(sizeof(const char*) * num);	pcmd->params.len = (int*)pkg_malloc(sizeof(int) * num);	pcmd->params.fmt = (int*)pkg_malloc(sizeof(int) * num);		if (!pcmd->params.val || 		!pcmd->params.len || !pcmd->params.fmt) {		ERR("postgres: No memory left/n");		goto error;	}		memset(pcmd->params.val, '/0', sizeof(const char*) * num);	memset(pcmd->params.len, '/0', sizeof(int) * num);	memset(pcmd->params.fmt, '/0', sizeof(int) * num);	pcmd->params.n = num;	return 0; error:	free_pg_params(&pcmd->params);	return -1;}

int my_getopt(db_cmd_t* cmd, char* optname, va_list ap){	struct my_cmd* mcmd;	long long* id;	int* val;	mcmd = (struct my_cmd*)DB_GET_PAYLOAD(cmd);	if (!strcasecmp("last_id", optname)) {		id = va_arg(ap, long long*);		if (id == NULL) {			BUG("mysql: NULL pointer passed to 'last_id' option/n");			goto error;		}		if (mcmd->st->last_errno != 0) {			BUG("mysql: Option 'last_id' called but previous command failed, "				"check your code/n");			return -1;		}		*id = mysql_stmt_insert_id(mcmd->st);		if ((*id) == 0) {			BUG("mysql: Option 'last_id' called but there is no auto-increment"				" column in table, SQL command: %.*s/n", STR_FMT(&mcmd->sql_cmd));			return -1;		}	} else if (!strcasecmp("fetch_all", optname)) {

/** Compare two connection URIs */static unsigned char pg_uri_cmp(db_uri_t* uri1, db_uri_t* uri2){	struct pg_uri* puri1, *puri2;	if (!uri1 || !uri2) return 0;	puri1 = DB_GET_PAYLOAD(uri1);	puri2 = DB_GET_PAYLOAD(uri2);	if (puri1->port != puri2->port) return 0;	if (cmpstr(puri1->username, puri2->username, strcmp)) return 0;	if (cmpstr(puri1->password, puri2->password, strcmp)) return 0;	if (cmpstr(puri1->host, puri2->host, strcasecmp)) return 0;	if (cmpstr(puri1->database, puri2->database, strcmp)) return 0;	return 1;}

static int build_result_array(char*** res, db_cmd_t* cmd){	struct ld_fld* lfld;	char** t;	int i;	if (cmd->result_count == 0) {		*res = NULL;		return 0;	}	t = (char**)pkg_malloc(sizeof(char*) * (cmd->result_count + 1));	if (t == NULL) {		ERR("ldap: No memory left/n");		return -1;	}	t[cmd->result_count] = NULL;	for(i = 0; i < cmd->result_count; i++) {		lfld = DB_GET_PAYLOAD(cmd->result + i);		/* Attribute names are always zero terminated */		t[i] = lfld->attr.s;	}	*res = t;	return 0;}

/* * Compare two connection identifiers */static unsigned char my_uri_cmp(db_uri_t* uri1, db_uri_t* uri2){	struct my_uri* muri1, *muri2;	if (!uri1 || !uri2) return 0;	muri1 = DB_GET_PAYLOAD(uri1);	muri2 = DB_GET_PAYLOAD(uri2);	if (muri1->port != muri2->port) return 0;	if (cmpstr(muri1->username, muri2->username, strcmp)) return 0;	if (cmpstr(muri1->password, muri2->password, strcmp)) return 0;	if (cmpstr(muri1->host, muri2->host, strcasecmp)) return 0;	if (cmpstr(muri1->database, muri2->database, strcmp)) return 0;	return 1;}

int my_cmd_exec(db_res_t* res, db_cmd_t* cmd){	struct my_cmd* mcmd;	mcmd = DB_GET_PAYLOAD(cmd);	mcmd->next_flag = -1;	return exec_cmd_safe(cmd);}

static int get_types(db_cmd_t* cmd){	struct pg_cmd* pcmd;	struct pg_con* pcon;	pcmd = DB_GET_PAYLOAD(cmd);	/* FIXME */	pcon = DB_GET_PAYLOAD(cmd->ctx->con[db_payload_idx]);	pcmd->types = PQdescribePrepared(pcon->con, pcmd->name);		if (PQresultStatus(pcmd->types) != PGRES_COMMAND_OK) {		ERR("postgres: Error while obtaining description of prepared statement/n");		return -1;	}	return 0;}

int bdb_cmd_next(db_res_t* res){	bdb_cmd_t *bcmd;	DBT key, data;	int ret;	static char dbuf[MAX_ROW_SIZE];	bcmd = DB_GET_PAYLOAD(res->cmd);	if (bcmd->next_flag == 2 || bcmd->next_flag == -2) return 1;	memset(&key, 0, sizeof(DBT));	memset(&data, 0, sizeof(DBT));	memset(dbuf, 0, MAX_ROW_SIZE);		data.data = dbuf;	data.ulen = MAX_ROW_SIZE;	data.flags = DB_DBT_USERMEM;	ret = 0;	if(bcmd->skey.len==0)	{		while((ret = bcmd->dbcp->c_get(bcmd->dbcp, &key, &data, DB_NEXT))==0)		{			if(!strncasecmp((char*)key.data,"METADATA",8)) 				continue;			break;		}		if(ret!=0)		{			bcmd->next_flag =  bcmd->next_flag<0?-2:2;			return 1;		}	} else {		key.data = bcmd->skey.s;		key.ulen = bcmd->skey_size;		key.flags = DB_DBT_USERMEM;		key.size = bcmd->skey.len;		ret = bcmd->dbcp->c_get(bcmd->dbcp, &key, &data, DB_NEXT);		if(ret!=0)		{			bcmd->next_flag = bcmd->next_flag<0?-2:2;			return 1;		}	}	if (bcmd->next_flag <= 0) {		bcmd->next_flag++;	}	if (bdb_update_result(res->cmd, &data) < 0) {		return -1;	}	res->cur_rec->fld = res->cmd->result;	return 0;}

int my_con(db_con_t* con){	struct my_con* ptr;	struct my_uri* uri;	/* First try to lookup the connection in the connection pool and	 * re-use it if a match is found	 */	ptr = (struct my_con*)db_pool_get(con->uri);	if (ptr) {		DBG("mysql: Connection to %.*s:%.*s found in connection pool/n",			con->uri->scheme.len, ZSW(con->uri->scheme.s),			con->uri->body.len, ZSW(con->uri->body.s));		goto found;	}	ptr = (struct my_con*)pkg_malloc(sizeof(struct my_con));	if (!ptr) {		LOG(L_ERR, "mysql: No memory left/n");		goto error;	}	memset(ptr, '/0', sizeof(struct my_con));	if (db_pool_entry_init(&ptr->gen, my_con_free, con->uri) < 0) goto error;	ptr->con = (MYSQL*)pkg_malloc(sizeof(MYSQL));	if (!ptr->con) {		LOG(L_ERR, "mysql: No enough memory/n");		goto error;	}	mysql_init(ptr->con);	uri = DB_GET_PAYLOAD(con->uri);	DBG("mysql: Creating new connection to: %.*s:%.*s/n",		con->uri->scheme.len, ZSW(con->uri->scheme.s),		con->uri->body.len, ZSW(con->uri->body.s));	/* Put the newly created mysql connection into the pool */	db_pool_put((struct db_pool_entry*)ptr);	DBG("mysql: Connection stored in connection pool/n"); found:	/* Attach driver payload to the db_con structure and set connect and	 * disconnect functions	 */	DB_SET_PAYLOAD(con, ptr);	con->connect = my_con_connect;	con->disconnect = my_con_disconnect;	return 0; error:	if (ptr) {		db_pool_entry_free(&ptr->gen);		if (ptr->con) pkg_free(ptr->con);		pkg_free(ptr);	}	return 0;}

/* Iterate to the next search result in the linked list * of messages returned by the LDAP server and convert * the field values. */static int search_entry(db_res_t* res, int init){	db_con_t* con;	struct ld_res* lres;	struct ld_con* lcon;	int r;	lres = DB_GET_PAYLOAD(res);	/* FIXME */	con = res->cmd->ctx->con[db_payload_idx];	lcon = DB_GET_PAYLOAD(con);	if (init	    || !lres->current	    || ldap_msgtype(lres->current) != LDAP_RES_SEARCH_ENTRY	    /* there is no more value combination result left */	    || ld_incindex(res->cmd->result)) {		do {			if (init) {				lres->current = ldap_first_message(lcon->con, lres->msg);				init = 0;			}			else				lres->current = ldap_next_message(lcon->con, lres->current);						while(lres->current) {				if (ldap_msgtype(lres->current) == LDAP_RES_SEARCH_ENTRY) {					break;				}				lres->current = ldap_next_message(lcon->con, lres->current);			}			if (lres->current == NULL) return 1;			r = ld_ldap2fldinit(res->cmd->result, lcon->con, lres->current);		} while (r > 0);		if (r < 0) return -1;	} else {		if (ld_ldap2fld(res->cmd->result, lcon->con, lres->current) < 0) return -1;	}	res->cur_rec->fld = res->cmd->result;	return 0;}

int bdb_con(db_con_t* con){	bdb_con_t* bcon;	bdb_uri_t* buri;	buri = DB_GET_PAYLOAD(con->uri);	/* First try to lookup the connection in the connection pool and	 * re-use it if a match is found	 */	bcon = (bdb_con_t*)db_pool_get(con->uri);	if (bcon) {		DBG("bdb: Connection to %s found in connection pool/n",			buri->uri);		goto found;	}	bcon = (bdb_con_t*)pkg_malloc(sizeof(bdb_con_t));	if (!bcon) {		ERR("bdb: No memory left/n");		goto error;	}	memset(bcon, '/0', sizeof(bdb_con_t));	if (db_pool_entry_init(&bcon->gen, bdb_con_free, con->uri) < 0) goto error;	DBG("bdb: Preparing new connection to %s/n", buri->uri);	if(bdb_is_database(buri->path.s)!=0)	{			ERR("bdb: database [%.*s] does not exists!/n",				buri->path.len, buri->path.s);		goto error;	}	/* Put the newly created BDB connection into the pool */	db_pool_put((struct db_pool_entry*)bcon);	DBG("bdb: Connection stored in connection pool/n");found:	/* Attach driver payload to the db_con structure and set connect and	 * disconnect functions	 */	DB_SET_PAYLOAD(con, bcon);	con->connect = bdb_con_connect;	con->disconnect = bdb_con_disconnect;	return 0;error:	if (bcon) {		db_pool_entry_free(&bcon->gen);		pkg_free(bcon);	}	return -1;}

void bdb_con_disconnect(db_con_t* con){	bdb_con_t *bcon;	bdb_uri_t *buri;	bcon = DB_GET_PAYLOAD(con);	buri = DB_GET_PAYLOAD(con->uri);	if ((bcon->flags & BDB_CONNECTED) == 0) return;	DBG("bdb: Unbinding from %s/n", buri->uri);	if(bcon->dbp==NULL)	{		bcon->flags &= ~BDB_CONNECTED;		return;	}	bdblib_close(bcon->dbp, &buri->path);	bcon->dbp = 0;	bcon->flags &= ~BDB_CONNECTED;}

void my_res_free(db_res_t* res, struct my_res* payload){	struct my_cmd* mcmd;	mcmd = DB_GET_PAYLOAD(res->cmd);	if (mcmd->st && mysql_stmt_free_result(mcmd->st)) {		ERR("mysql: Error while freeing MySQL result: %d, %s/n",			mysql_stmt_errno(mcmd->st), mysql_stmt_error(mcmd->st));	}	db_drv_free(&payload->gen);	pkg_free(payload);}

int bdb_cmd(db_cmd_t *cmd){	bdb_cmd_t *bcmd;	db_con_t *con;	bdb_con_t *bcon;	bcmd = (bdb_cmd_t *)pkg_malloc(sizeof(bdb_cmd_t));	if(bcmd == NULL) {		ERR("bdb: No memory left/n");		goto error;	}	memset(bcmd, '/0', sizeof(bdb_cmd_t));	if(db_drv_init(&bcmd->gen, bdb_cmd_free) < 0)		goto error;	con = cmd->ctx->con[db_payload_idx];	bcon = DB_GET_PAYLOAD(con);	bcmd->bcon = bcon;	switch(cmd->type) {		case DB_PUT:		case DB_DEL:		case DB_UPD:			ERR("bdb: The driver does not support DB modifications yet./n");			goto error;			break;		case DB_GET:			if(bdb_prepare_query(cmd, bcmd) != 0) {				ERR("bdb: error preparing query./n");				goto error;			}			break;		case DB_SQL:			ERR("bdb: The driver does not support raw queries yet./n");			goto error;	}	DB_SET_PAYLOAD(cmd, bcmd);	return 0;error:	if(bcmd) {		DB_SET_PAYLOAD(cmd, NULL);		db_drv_free(&bcmd->gen);		pkg_free(bcmd);	}	return -1;}

/** * Set MYSQL_BIND item. * @param bind destination * @param fld  source */static void set_field(MYSQL_BIND *bind, db_fld_t* fld){	struct my_fld* f;		f = DB_GET_PAYLOAD(fld);	bind->is_null = &f->is_null;	/* We can do it for all the types here, mysql will ignore it	 * for fixed-size types such as MYSQL_TYPE_LONG	 */	bind->length = &f->length;	switch(fld->type) {	case DB_INT:	case DB_BITMAP:		bind->buffer_type = MYSQL_TYPE_LONG;		bind->buffer = &fld->v.int4;		break;		case DB_FLOAT:		bind->buffer_type = MYSQL_TYPE_FLOAT;		bind->buffer = &fld->v.flt;		break;			case DB_DOUBLE:		bind->buffer_type = MYSQL_TYPE_DOUBLE;		bind->buffer = &fld->v.dbl;		break;		case DB_DATETIME:		bind->buffer_type = MYSQL_TYPE_DATETIME;		bind->buffer = &f->time;		break;		case DB_STR:	case DB_CSTR:		bind->buffer_type = MYSQL_TYPE_VAR_STRING;		bind->buffer = ""; /* Updated on runtime */		break;		case DB_BLOB:		bind->buffer_type = MYSQL_TYPE_BLOB;		bind->buffer = ""; /* Updated on runtime */		break;		case DB_NONE:		/* Eliminates gcc warning */		break;		}}

int my_cmd_next(db_res_t* res){	int ret;	struct my_cmd* mcmd;	mcmd = DB_GET_PAYLOAD(res->cmd);	if (mcmd->next_flag == 2 || mcmd->next_flag == -2) return 1;	if (mcmd->st == NULL) {		ERR("mysql: Prepared statement not found/n");		return -1;	}	ret = mysql_stmt_fetch(mcmd->st);		if (ret == MYSQL_NO_DATA) {		mcmd->next_flag =  mcmd->next_flag<0?-2:2;		return 1;	}	/* MYSQL_DATA_TRUNCATED is only defined in mysql >= 5.0 */#if defined MYSQL_DATA_TRUNCATED	if (ret == MYSQL_DATA_TRUNCATED) {		int i;		ERR("mysql: mysql_stmt_fetch, data truncated, fields: %d/n", res->cmd->result_count);		for (i = 0; i < res->cmd->result_count; i++) {			if (mcmd->st->bind[i].error /*&& mcmd->st->bind[i].buffer_length*/) {				ERR("mysql: truncation, bind %d, length: %lu, buffer_length: %lu/n", 					i, *(mcmd->st->bind[i].length), mcmd->st->bind[i].buffer_length);			}		}		ret = 0;	}#endif	if (mcmd->next_flag <= 0) {		mcmd->next_flag++;	}	if (ret != 0) {		ERR("mysql: Error in mysql_stmt_fetch (ret=%d): %s/n", ret, mysql_stmt_error(mcmd->st));		return -1;	}	if (update_result(res->cmd->result, mcmd->st) < 0) {		mysql_stmt_free_result(mcmd->st);		return -1;	}	res->cur_rec->fld = res->cmd->result;	return 0;}

void ld_con_disconnect(db_con_t* con){	struct ld_con* lcon;	struct ld_uri* luri;	int ret;	lcon = DB_GET_PAYLOAD(con);	luri = DB_GET_PAYLOAD(con->uri);	if ((lcon->flags & LD_CONNECTED) == 0) return;	DBG("ldap: Unbinding from %s/n", luri->uri);	if (lcon->con) {		ret = ldap_unbind_ext_s(lcon->con, NULL, NULL);		if (ret) {			ERR("ldap: Error while unbinding from %s: %s/n",				luri->uri, ldap_err2string(ret));		}	}	lcon->con = NULL;	lcon->flags &= ~LD_CONNECTED;}

int ld_resolve_fld(db_fld_t* fld, struct ld_cfg* cfg){	int i;	struct ld_fld* lfld;	if (fld == NULL || cfg == NULL) return 0;	for(i = 0; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) {		lfld = DB_GET_PAYLOAD(fld + i);		lfld->attr.s = ld_find_attr_name(&lfld->syntax, cfg, fld[i].name);		if (lfld->attr.s == NULL) lfld->attr.s = fld[i].name;		if (lfld->attr.s) lfld->attr.len = strlen(lfld->attr.s);	}	return 0;}

void my_con_disconnect(db_con_t* con){	struct my_con* mcon;	mcon = DB_GET_PAYLOAD(con);	if ((mcon->flags & MY_CONNECTED) == 0) return;	DBG("mysql: Disconnecting from %.*s:%.*s/n",		con->uri->scheme.len, ZSW(con->uri->scheme.s),		con->uri->body.len, ZSW(con->uri->body.s));	mysql_close(mcon->con);	mcon->flags &= ~MY_CONNECTED;}

int pg_getopt(db_cmd_t* cmd, char* optname, va_list ap){	struct pg_cmd* pcmd;	long long* id;	pcmd = (struct pg_cmd*)DB_GET_PAYLOAD(cmd);	if (!strcasecmp("last_id", optname)) {		id = va_arg(ap, long long*);		if (id == NULL) {			BUG("postgres: NULL pointer passed to 'last_id' option/n");			goto error;		}		return -1;	} else {

void bdb_res_free(db_res_t* res, bdb_res_t *payload){	bdb_cmd_t *bcmd;	bcmd = DB_GET_PAYLOAD(res->cmd);	/* free bdb result */	if(bcmd->dbcp!=NULL)	{		bcmd->dbcp->CLOSE_CURSOR(bcmd->dbcp);		bcmd->dbcp = NULL;	}	db_drv_free(&payload->gen);	pkg_free(payload);}

void pg_con_disconnect(db_con_t *con){	struct pg_con *pcon;	pcon = DB_GET_PAYLOAD(con);	if((pcon->flags & PG_CONNECTED) == 0)		return;	DBG("postgres: Disconnecting from %.*s:%.*s/n", con->uri->scheme.len,			ZSW(con->uri->scheme.s), con->uri->body.len, ZSW(con->uri->body.s));	PQfinish(pcon->con);	pcon->con = NULL;	pcon->flags &= ~PG_CONNECTED;	pcon->flags &= ~PG_INT8_TIMESTAMP;}

int ld_con(db_con_t* con){	struct ld_con* lcon;	struct ld_uri* luri;	luri = DB_GET_PAYLOAD(con->uri);	/* First try to lookup the connection in the connection pool and	 * re-use it if a match is found	 */	lcon = (struct ld_con*)db_pool_get(con->uri);	if (lcon) {		DBG("ldap: Connection to %s found in connection pool/n",			luri->uri);		goto found;	}	lcon = (struct ld_con*)pkg_malloc(sizeof(struct ld_con));	if (!lcon) {		ERR("ldap: No memory left/n");		goto error;	}	memset(lcon, '/0', sizeof(struct ld_con));	if (db_pool_entry_init(&lcon->gen, ld_con_free, con->uri) < 0) goto error;	DBG("ldap: Preparing new connection to %s/n", luri->uri);	/* Put the newly created LDAP connection into the pool */	db_pool_put((struct db_pool_entry*)lcon);	DBG("ldap: Connection stored in connection pool/n"); found:	/* Attach driver payload to the db_con structure and set connect and	 * disconnect functions	 */	DB_SET_PAYLOAD(con, lcon);	con->connect = ld_con_connect;	con->disconnect = ld_con_disconnect;	return 0; error:	if (lcon) {		db_pool_entry_free(&lcon->gen);		pkg_free(lcon);	}	return -1;}

int my_cmd_first(db_res_t* res) {	struct my_cmd* mcmd;	mcmd = DB_GET_PAYLOAD(res->cmd);	switch (mcmd->next_flag) {	case -2: /* table is empty */		return 1;	case 0:  /* cursor position is 0 */		return 0;	case 1:  /* next row */	case 2:  /* EOF */		ERR("mysql: Unbuffered queries do not support cursor reset./n");		return -1;	default:		return my_cmd_next(res);	}}