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

static int	housekeeping_events(int now){	const char	*__function_name = "housekeeping_events";	int		event_history, deleted = 0;	DB_RESULT	result;	DB_ROW		row;	zbx_uint64_t	eventid;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() now:%d", __function_name, now);	result = DBselect("select eventid from events where clock<%d",			now - *(int *)DCconfig_get_config_data(&event_history, CONFIG_EVENT_HISTORY) * SEC_PER_DAY);	while (NULL != (row = DBfetch(result)))	{		ZBX_STR2UINT64(eventid, row[0]);		DBexecute("delete from acknowledges where eventid=" ZBX_FS_UI64, eventid);		deleted += DBexecute("delete from events where eventid=" ZBX_FS_UI64, eventid);	}	DBfree_result(result);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, deleted);	return deleted;}

/****************************************************************************** *                                                                            * * Function: update_checksums                                                 * *                                                                            * * Purpose: overwrite old checksums with new ones                             * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value: SUCCESS - calculated succesfully                             * *               FAIL - an error occured                                      * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static int update_checksums(){    DBexecute("delete from node_cksum where cksumtype=%d",              NODE_CKSUM_TYPE_OLD);    DBexecute("update node_cksum set cksumtype=%d where cksumtype=%d",              NODE_CKSUM_TYPE_OLD,              NODE_CKSUM_TYPE_NEW);    return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: housekeeping_process_log                                         * *                                                                            * * Purpose: process table 'housekeeper' and remove data if required           * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value: SUCCEED - information removed succesfully                    * *               FAIL - otherwise                                             * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static int housekeeping_process_log(){	DB_HOUSEKEEPER	housekeeper;	DB_RESULT	result;	DB_ROW		row;	int		res = SUCCEED;	long		deleted;	zabbix_log( LOG_LEVEL_DEBUG, "In housekeeping_process_log()");	/* order by tablename to effectively use DB cache */	result = DBselect("select housekeeperid, tablename, field, value from housekeeper order by tablename");	while((row=DBfetch(result)))	{		ZBX_STR2UINT64(housekeeper.housekeeperid,row[0]);		housekeeper.tablename=row[1];		housekeeper.field=row[2];		ZBX_STR2UINT64(housekeeper.value,row[3]);#ifdef HAVE_ORACLE		deleted = DBexecute("delete from %s where %s=" ZBX_FS_UI64 " and rownum<500",			housekeeper.tablename,			housekeeper.field,			housekeeper.value);#elif defined(HAVE_POSTGRESQL)		deleted = DBexecute("delete from %s where oid in (select oid from %s where %s=" ZBX_FS_UI64 " limit 500)",				housekeeper.tablename, 				housekeeper.tablename, 				housekeeper.field,				housekeeper.value);#else		deleted = DBexecute("delete from %s where %s=" ZBX_FS_UI64 " limit 500",			housekeeper.tablename,			housekeeper.field,			housekeeper.value);#endif		if(deleted == 0)		{			DBexecute("delete from housekeeper where housekeeperid=" ZBX_FS_UI64,				housekeeper.housekeeperid);		}		else		{			zabbix_log( LOG_LEVEL_DEBUG, "Deleted [%ld] records from table [%s]",				deleted,				housekeeper.tablename);		}	}	DBfree_result(result);	return res;}

/****************************************************************************** *                                                                            * * Function: process_deleted_records                                          * *                                                                            * * Purpose:                                                                   * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static void	process_deleted_records(int nodeid, char *data, int sender_nodetype){	const char	*__function_name = "process_deleted_records";	char		*r, *lf;	const ZBX_TABLE	*table = NULL;	zbx_uint64_t	recid, *ids = NULL;	int		ids_alloc = 0, ids_num = 0;	char		*sql = NULL;	size_t		sql_alloc = 4 * ZBX_KIBIBYTE, sql_offset = 0;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	sql = zbx_malloc(sql, sql_alloc);	DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);	for (r = data; '/0' != *r;)	{		if (NULL != (lf = strchr(r, '/n')))			*lf = '/0';		zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);		if (NULL == table || 0 != strcmp(table->table, buf))		{			make_delete_sql(&sql, &sql_alloc, &sql_offset, table, ids, &ids_num);			if (NULL == (table = DBget_table(buf)))			{				zabbix_log(LOG_LEVEL_DEBUG, "%s(): cannot find table [%s]", __function_name, buf);				goto next;			}		}		zbx_get_next_field((const char **)&r, &buf, &buf_alloc, ZBX_DM_DELIMITER);		ZBX_STR2UINT64(recid, buf);		if ('2' == *r)	/* NODE_CONFIGLOG_OP_DELETE */			uint64_array_add(&ids, &ids_alloc, &ids_num, recid, 64);next:		if (lf != NULL)		{			*lf++ = '/n';			r = lf;		}		else			break;	}	make_delete_sql(&sql, &sql_alloc, &sql_offset, table, ids, &ids_num);	DBend_multiple_update(&sql, &sql_alloc, &sql_offset);	if (sql_offset > 16)	/* In ORACLE always present begin..end; */		DBexecute("%s", sql);	zbx_free(sql);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

/****************************************************************************** *                                                                            * * Function:                                                                  * *                                                                            * * Purpose:                                                                   * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int ja_host_lock(const char *host, const zbx_uint64_t inner_job_id){    int db_ret;    char *host_esc;    const char *__function_name = "ja_host_lock";    zabbix_log(LOG_LEVEL_DEBUG, "In %s() host: %s", __function_name, host);    if (ja_host_getip(host, NULL, inner_job_id, NULL, JA_TXN_ON) == 0)        return FAIL;    DBfree_result(DBselect                  ("select lock_host_name from ja_host_lock_table where lock_host_name = 'HOST_LOCK_RECORD' for update"));    host_esc = DBdyn_escape_string(host);    db_ret =        DBexecute        ("insert into ja_host_lock_table (lock_host_name) values ('%s')",         host_esc);    zbx_free(host_esc);    if (db_ret < ZBX_DB_OK) {        ja_log("JAHOST200005", 0, NULL, inner_job_id, __function_name, host, inner_job_id);        return FAIL;    } else {        return SUCCEED;    }}

static int	DBpatch_2030113(void){	if (ZBX_DB_OK > DBexecute("delete from profiles where idx in ('web.latest.php.sort', 'web.httpmon.php.sort')"))		return FAIL;	return SUCCEED;}

static int	DBpatch_2030028(void){	if (ZBX_DB_OK > DBexecute("update items set formula='' where flags=%d", ZBX_FLAG_DISCOVERY_RULE))		return FAIL;	return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: op_host_disable                                                  * *                                                                            * * Purpose: disable host                                                      * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/void	op_host_disable(DB_EVENT *event){	const char	*__function_name = "op_host_disable";	zbx_uint64_t	hostid;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (event->source != EVENT_SOURCE_DISCOVERY && event->source != EVENT_SOURCE_AUTO_REGISTRATION)		return;	if (event->object != EVENT_OBJECT_DHOST && event->object != EVENT_OBJECT_DSERVICE && event->object != EVENT_OBJECT_ZABBIX_ACTIVE)		return;	if (0 == (hostid = add_discovered_host(event)))		return;	DBexecute(			"update hosts"			" set status=%d"			" where hostid=" ZBX_FS_UI64,			HOST_STATUS_NOT_MONITORED,			hostid);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

void	zbx_db_init(char *dbname){#if defined(HAVE_SQLITE3)	struct stat	buf;	if (0 != stat(dbname, &buf))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot open database file /"%s/": %s", dbname, zbx_strerror(errno));		zabbix_log(LOG_LEVEL_WARNING, "creating database ...");		if (SQLITE_OK != sqlite3_open(dbname, &conn))		{			zabbix_errlog(ERR_Z3002, dbname, 0, sqlite3_errmsg(conn));			exit(FAIL);		}		zbx_create_sqlite3_mutex(dbname);		DBexecute("%s", db_schema);		DBclose();	}	else		zbx_create_sqlite3_mutex(dbname);#endif	/* HAVE_SQLITE3 */}

static int	DBpatch_2010068(void){	if (ZBX_DB_OK <= DBexecute(			"update config"			" set hk_events_mode=0,"				"hk_services_mode=0,"				"hk_audit_mode=0,"				"hk_sessions_mode=0,"				"hk_history_mode=0,"				"hk_trends_mode=0,"				"hk_events_trigger="					"case when event_history>alert_history"					" then event_history else alert_history end,"				"hk_events_discovery="					"case when event_history>alert_history"					" then event_history else alert_history end,"				"hk_events_autoreg="					"case when event_history>alert_history"					" then event_history else alert_history end,"				"hk_events_internal="					"case when event_history>alert_history"					" then event_history else alert_history end"))	{		return SUCCEED;	}	return FAIL;}

/****************************************************************************** *                                                                            * * Function: register_host                                                    * *                                                                            * * Purpose: register host if one does not exist                               * *                                                                            * * Parameters: host ip address                                                * *                                                                            * * Return value: dhostid or 0 if we didn't add host                           * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static void register_host(DB_DHOST *host,DB_DCHECK *check, zbx_uint64_t druleid, char *ip){	DB_RESULT	result;	DB_ROW		row;	char		hostname[MAX_STRING_LEN], hostname_esc[MAX_STRING_LEN];	assert(host);	assert(check);	assert(ip);	zabbix_log(LOG_LEVEL_DEBUG, "In register_host(ip:%s)",		ip);	host->dhostid=0;	result = DBselect("select dhostid,druleid,ip,status,lastup,lastdown from dhosts where ip='%s'", ip);	row=DBfetch(result);	if(!row || DBis_null(row[0])==SUCCEED)	{		/* Add host only if service is up */		if(check->status == DOBJECT_STATUS_UP)		{			alarm(CONFIG_TIMEOUT);			zbx_gethost_by_ip(ip, hostname, sizeof(hostname));			alarm(0);			if (hostname[0] != '/0')				DBescape_string(hostname, hostname_esc, sizeof(hostname_esc));			else				hostname_esc[0] = '/0';			zabbix_log(LOG_LEVEL_DEBUG, "New host discovered at %s (%s)",				ip, hostname);			host->dhostid = DBget_maxid("dhosts","dhostid");			DBexecute("insert into dhosts (dhostid, druleid, dns, ip) values (" ZBX_FS_UI64 "," ZBX_FS_UI64 ", '%s','%s')",				host->dhostid,				druleid,				hostname_esc,				ip);			host->druleid	= druleid;			strscpy(host->ip,ip);			host->status	= 0;			host->lastup	= 0;			host->lastdown  = 0;		}	}	else	{		zabbix_log(LOG_LEVEL_DEBUG, "Host is already in database");		ZBX_STR2UINT64(host->dhostid,row[0]);		ZBX_STR2UINT64(host->druleid,row[1]);		strscpy(host->ip,	row[2]);		host->status		= atoi(row[3]);		host->lastup		= atoi(row[4]);		host->lastdown		= atoi(row[5]);	}	DBfree_result(result);	zabbix_log(LOG_LEVEL_DEBUG, "End register_host()");}

static int	DBpatch_2010037(void){	if (ZBX_DB_OK <= DBexecute("update config set server_check_interval=10"))		return SUCCEED;	return FAIL;}

static int	DBpatch_2010050(void){	char		*fields[] = {"ts_from", "ts_to", NULL};	DB_RESULT	result;	DB_ROW		row;	int		i;	time_t		ts;	struct tm	*tm;	for (i = 0; NULL != fields[i]; i++)	{		result = DBselect(				"select timeid,%s"				" from services_times"				" where type in (%d,%d)"					" and %s>%d",				fields[i], 0 /* SERVICE_TIME_TYPE_UPTIME */, 1 /* SERVICE_TIME_TYPE_DOWNTIME */,				fields[i], SEC_PER_WEEK);		while (NULL != (row = DBfetch(result)))		{			if (SEC_PER_WEEK < (ts = (time_t)atoi(row[1])))			{				tm = localtime(&ts);				ts = tm->tm_wday * SEC_PER_DAY + tm->tm_hour * SEC_PER_HOUR + tm->tm_min * SEC_PER_MIN;				DBexecute("update services_times set %s=%d where timeid=%s",						fields[i], (int)ts, row[0]);			}		}		DBfree_result(result);	}	return SUCCEED;}

static int	DBpatch_2010185(void){	if (ZBX_DB_OK > DBexecute("update sysmaps_elements set label_location=-1 where label_location is null"))		return FAIL;	return SUCCEED;}

static int	DBpatch_2010176(void){	DB_RESULT	result;	DB_ROW		row;	char		*name, *name_esc;	int		ret = SUCCEED;	result = DBselect("select scriptid,name from scripts");	while (SUCCEED == ret && NULL != (row = DBfetch(result)))	{		name = zbx_dyn_escape_string(row[1], "///");		if (0 != strcmp(name, row[1]))		{			name_esc = DBdyn_escape_string_len(name, 255);			if (ZBX_DB_OK > DBexecute("update scripts set name='%s' where scriptid=%s", name_esc, row[0]))				ret = FAIL;			zbx_free(name_esc);		}		zbx_free(name);	}	DBfree_result(result);	return ret;}

static int	DBpatch_2030065(void){	DB_RESULT	result;	DB_ROW		row;	int		local_nodeid = 0;	zbx_uint64_t	min, max;	/* 1 - ZBX_NODE_LOCAL */	if (NULL == (result = DBselect("select nodeid from nodes where nodetype=1")))		return FAIL;	if (NULL != (row = DBfetch(result)))		local_nodeid = atoi(row[0]);	DBfree_result(result);	if (0 == local_nodeid)		return SUCCEED;	min = local_nodeid * __UINT64_C(100000000000000);	max = min + __UINT64_C(100000000000000) - 1;	if (ZBX_DB_OK <= DBexecute(			"delete from config where not configid between " ZBX_FS_UI64 " and " ZBX_FS_UI64, min, max))	{		return SUCCEED;	}	return FAIL;}

static int	DBcreate_dbversion_table(void){	const ZBX_TABLE	table =			{"dbversion", "", 0,				{					{"mandatory", "0", NULL, NULL, 0, ZBX_TYPE_INT, ZBX_NOTNULL, 0},					{"optional", "0", NULL, NULL, 0, ZBX_TYPE_INT, ZBX_NOTNULL, 0},					{NULL}				}			};	int		ret;	DBbegin();	if (SUCCEED == (ret = DBcreate_table(&table)))	{		if (ZBX_DB_OK > DBexecute("insert into dbversion (mandatory,optional) values (%d,%d)",				ZBX_FIRST_DB_VERSION, ZBX_FIRST_DB_VERSION))		{			ret = FAIL;		}	}	DBend(ret);	return ret;}

static int	DBpatch_2010080(void){	DB_RESULT	result;	DB_ROW		row;	zbx_uint64_t	applicationid, templateid, application_templateid = 1;	int		ret = FAIL;	result = DBselect("select applicationid,templateid from applications where templateid is not null");	while (NULL != (row = DBfetch(result)))	{		ZBX_STR2UINT64(applicationid, row[0]);		ZBX_STR2UINT64(templateid, row[1]);		if (ZBX_DB_OK > DBexecute(				"insert into application_template"					" (application_templateid,applicationid,templateid)"					" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ")",				application_templateid++, applicationid, templateid))		{			goto out;		}	}	ret = SUCCEED;out:	DBfree_result(result);	return ret;}

/****************************************************************************** *                                                                            * * Function: tm_remove_old_tasks                                              * *                                                                            * * Purpose: remove old done/expired tasks                                     * *                                                                            * ******************************************************************************/static void	tm_remove_old_tasks(int now){	DBbegin();	DBexecute("delete from task where status in (%d,%d) and clock<=%d",			ZBX_TM_STATUS_DONE, ZBX_TM_STATUS_EXPIRED, now - ZBX_TM_CLEANUP_TASK_AGE);	DBcommit();}

static int housekeeping_alerts(int now){	int	alert_history;	DB_RESULT	result;	DB_ROW		row;	int		res = SUCCEED;	int		deleted;	zabbix_log( LOG_LEVEL_DEBUG, "In housekeeping_alerts(%d)",		now);	result = DBselect("select alert_history from config");	row=DBfetch(result);	if(!row || DBis_null(row[0])==SUCCEED)	{		zabbix_log( LOG_LEVEL_ERR, "No records in table 'config'.");		res = FAIL;	}	else	{		alert_history=atoi(row[0]);		deleted = DBexecute("delete from alerts where clock<%d",			now-24*3600*alert_history);		zabbix_log( LOG_LEVEL_DEBUG, "Deleted [%ld] records from table [alerts]",			deleted);	}	DBfree_result(result);	return res;}

static void	add_command_alert(DB_ESCALATION *escalation, DB_EVENT *event, DB_ACTION *action, char *command){	zbx_uint64_t	alertid;	int		now;	char		*command_esc;	zabbix_log(LOG_LEVEL_DEBUG, "In add_command_alert()");	alertid		= DBget_maxid("alerts", "alertid");	now		= time(NULL);	command_esc	= DBdyn_escape_string(command);	DBexecute("insert into alerts (alertid,actionid,eventid,clock,message,status,alerttype,esc_step)"			" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,'%s',%d,%d,%d)",			alertid,			action->actionid,			event->eventid,			now,			command_esc,			ALERT_STATUS_SENT,			ALERT_TYPE_COMMAND,			escalation->esc_step);	op_run_commands(command);	zbx_free(command_esc);}

static int housekeeping_events(int now){	int		event_history;	DB_RESULT	result;	DB_ROW		row1;	int		res = SUCCEED;	zabbix_log( LOG_LEVEL_DEBUG, "In housekeeping_events(%d)",		now);	result = DBselect("select event_history from config");	row1=DBfetch(result);		if(!row1 || DBis_null(row1[0])==SUCCEED)	{		zabbix_log( LOG_LEVEL_ERR, "No records in table 'config'.");		res = FAIL;	}	else	{		event_history=atoi(row1[0]);		DBexecute ("delete from events where clock < %d", now-24*3600*event_history);	}		DBfree_result(result);	return res;}

/****************************************************************************** *                                                                            * * Function: op_group_del                                                     * *                                                                            * * Purpose: delete group from discovered host                                 * *                                                                            * * Parameters: event   - [IN] event data                                      * *             groupid - [IN] group identificator from database               * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * ******************************************************************************/void	op_group_del(DB_EVENT *event, zbx_uint64_t groupid){	const char	*__function_name = "op_group_del";	zbx_uint64_t	hostid;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (event->source != EVENT_SOURCE_DISCOVERY)		return;	if (event->object != EVENT_OBJECT_DHOST && event->object != EVENT_OBJECT_DSERVICE)		return;	if (0 == (hostid = select_discovered_host(event)))		return;	DBexecute(			"delete from hosts_groups"			" where hostid=" ZBX_FS_UI64				" and groupid=" ZBX_FS_UI64,			hostid,			groupid);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

static void	add_command_alert(DC_HOST *host, zbx_uint64_t eventid, zbx_uint64_t actionid,		int esc_step, const char *command, zbx_alert_status_t status, const char *error){	const char	*__function_name = "add_command_alert";	zbx_uint64_t	alertid;	int		now;	char		*tmp = NULL, *command_esc, *error_esc;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	alertid = DBget_maxid("alerts");	now = (int)time(NULL);	tmp = zbx_dsprintf(tmp, "%s:%s", host->host, NULL == command ? "" : command);	command_esc = DBdyn_escape_string_len(tmp, ALERT_MESSAGE_LEN);	error_esc = DBdyn_escape_string_len(error, ALERT_ERROR_LEN);	zbx_free(tmp);	DBexecute("insert into alerts"			" (alertid,actionid,eventid,clock,message,status,error,alerttype,esc_step)"			" values "			"(" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,'%s',%d,'%s',%d,%d)",			alertid, actionid, eventid, now, command_esc, (int)status,			error_esc, ALERT_TYPE_COMMAND, esc_step);	zbx_free(error_esc);	zbx_free(command_esc);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

static int	DBpatch_2030110(void){	if (ZBX_DB_OK > DBexecute("delete from profiles where idx='web.view.application'"))		return FAIL;	return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: delete_history                                                   * *                                                                            * * Purpose: remove outdated information from historical table                 * *                                                                            * * Parameters: now - current timestamp                                        * *                                                                            * * Return value: number of rows deleted                                       * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static int	delete_history(const char *table, zbx_uint64_t itemid, int keep_history, int now){	const char	*__function_name = "delete_history";	DB_RESULT       result;	DB_ROW          row;	int             min_clock, deleted;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() table:'%s' itemid:" ZBX_FS_UI64 " keep_history:%d now:%d",		__function_name, table, itemid, keep_history, now);	result = DBselect("select min(clock) from %s where itemid=" ZBX_FS_UI64, table, itemid);	if (NULL == (row = DBfetch(result)) || SUCCEED == DBis_null(row[0]))	{		DBfree_result(result);		return 0;	}	min_clock = atoi(row[0]);	min_clock = MIN(now - keep_history * SEC_PER_DAY, min_clock + 4 * CONFIG_HOUSEKEEPING_FREQUENCY * SEC_PER_HOUR);	DBfree_result(result);	deleted = DBexecute("delete from %s where itemid=" ZBX_FS_UI64 " and clock<%d", table, itemid, min_clock);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, deleted);	return deleted;}

static int	DBpatch_2030114(void){	if (ZBX_DB_OK > DBexecute("delete from profiles where idx='web.httpconf.php.sort' and value_str='h.hostid'"))		return FAIL;	return SUCCEED;}

static int	DBpatch_2030109(void){	if (ZBX_DB_OK <= DBexecute("update screens_items set rowspan=1 where rowspan=0"))		return SUCCEED;	return FAIL;}