static void takeover_cave(db_t *database,
		   int    cave_id,
		   int    attacker_id,
		   const char   *return_start)
{
  /* change owner of cave */
  db_query(database, "UPDATE " DB_TABLE_CAVE " SET playerID = %d"
		     " WHERE caveID = %d", attacker_id, cave_id);

  dstring_t *ds;
  ds = dstring_new("UPDATE Event_movement SET target_caveID = source_caveID, ");
  dstring_append(ds, "end = addtime('%s',timediff('%s',start)), ",return_start,return_start);
  dstring_append(ds, "start='%s', ",return_start);
  dstring_append(ds, "movementID = 5 where caveID = %d and caveID = source_caveID",cave_id);
  debug(DEBUG_SQL, "Torben %s", dstring_str(ds));
  db_query_dstring(database, ds);


  /* delete research from event table*/
  db_query(database, "DELETE FROM Event_science WHERE caveID = %d", cave_id);

  /* copy sciences from new owner to cave */
  science_update_caves(database, attacker_id);
}

int DBConnectionUp()
{
	mysql_init(&db_read_connection);
	mysql_init(&db_write_connection);
	mysql_init(&payguide::db_checkreqs_connection);
	MYSQL *tmp1=mysql_real_connect(&db_read_connection, payguide::host_saved.c_str(), payguide::user_saved.c_str(), payguide::passwor_saved.c_str(), payguide::db_name_saved.c_str(), 0, NULL, 0);
	MYSQL *tmp2=mysql_real_connect(&db_write_connection, payguide::host_saved.c_str(), payguide::user_saved.c_str(), payguide::passwor_saved.c_str(), payguide::db_name_saved.c_str(), 0, NULL, 0);
	MYSQL *tmp3=mysql_real_connect(&payguide::db_checkreqs_connection, payguide::host_saved.c_str(), payguide::user_saved.c_str(), payguide::passwor_saved.c_str(), payguide::db_name_saved.c_str(), 0, NULL, 0);
	
		if (tmp1==NULL || tmp2==NULL || tmp3==NULL)
		{
			std::cout << "MySQL connection failed. Please, check out login, password, host and database name options." << std::endl;
			return 2;
		}
	
	int r=db_query(&db_write_connection, "set names koi8r");
	r=r+db_query(&db_read_connection, "set names koi8r");
	r=r+db_query(&payguide::db_checkreqs_connection, "set names koi8r");
	if (r!=0) 
		std::cout << "Failed to execute SQL comand: \"set names koi8r\"" << std::endl;

	db_down=0;
	return 0;
}

CWERROR db_reports_get_list(CW_DB_CONNECTION *db,
                            CW_REPORT **rlist,
                            CW_UINT32 *count)
{
	static const char query[] = "SELECT rid,sid,uid,datetime(add_dt,'localtime'),code FROM reports ORDER BY add_dt COLLATE NOCASE DESC";
	    
    CW_DB_RESULT       res;
	CW_DB_RESULT_ROW   *row;
	CW_REPORT          *list = NULL;
	CW_UINT32          n, i = 0;
	CWERROR	           err = CW_ER_OK;

	if ((err = db_query(db, &res, query, sizeof(query)-1, NULL, 0)) != CW_ER_OK) {
        DEBUG_ERROR();
        db_result_free(&res);
        return err;
    }

    if ((n = *count = DB_RESULT_ROW_COUNT(res)) == 0) {
        db_result_free(&res);
        return CW_ER_OK;
    }

    if ((list = *rlist = DLL_MALLOC(sizeof(CW_REPORT) * n)) == NULL) {
		DEBUG_ERROR();
		db_result_free(&res);
		return CW_ER_MEMORY;
	}

	row = DB_RESULT_ROW_FIRST(res);
	do {
        list[i].rid = DB_RESULT_AS_INT64(row, 0);
        list[i].pckt.rcpt_sid = (CW_UINT32)DB_RESULT_AS_INT64(row, 1);
        list[i].pckt.rcpt_uid = (CW_UINT32)DB_RESULT_AS_INT64(row, 2);
        if (strcpy_s(list[i].add_dt, DB_RESULT_AS_TEXT(row, 3), sizeof(list[i].add_dt)) == NULL) {
            DEBUG_ERROR();
            DLL_FREE(list);
            db_result_free(&res);
            return CW_ER_INTERNAL;
        }
	    list[i].pckt.code = (CW_UINT32)DB_RESULT_AS_INT64(row, 4);
        ++i;
    } while (((row = DB_RESULT_ROW_NEXT(row)) != NULL) && (--n));

    db_result_free(&res);

    return CW_ER_OK;
}

static void process_trust_0002(const char * string, const jsmntok_t * tokens, const int index)
{
   char query[1024];
   char train_id[128], reason[128], type[128], stanox[128];
   
   jsmn_find_extract_token(string, tokens, index, "train_id", train_id, sizeof(train_id));
   jsmn_find_extract_token(string, tokens, index, "canx_reason_code", reason, sizeof(reason));
   jsmn_find_extract_token(string, tokens, index, "canx_type", type, sizeof(type));
   jsmn_find_extract_token(string, tokens, index, "loc_stanox", stanox, sizeof(stanox));

   time_t now = time(NULL);
   sprintf(query, "INSERT INTO trust_cancellation VALUES(%ld, '%s', '%s', '%s', '%s', 0)", now, train_id, reason, type, stanox);
   db_query(query);
   
   return;
}

int db_insert(char *data) {
	int value;
	char *sqlquery;
	
	sqlquery = sqlite3_mprintf(
		"INSERT INTO notifications (timestamp, read, message) "
		"VALUES (%u, 0, '%q')",
		time(NULL),
		data
	);
	
	value = db_query(db, sqlquery);	
	sqlite3_free(sqlquery);
	
	return value;
}

/*
 * Retrieve player table information for the given player id.
 */
void get_player_info (db_t *database, int player_id, struct Player *player)
{
  db_result_t *result = db_query(database,
	"SELECT * FROM " DB_TABLE_PLAYER " WHERE playerID = %d", player_id);

  if (!db_result_next_row(result))
    throwf(SQL_EXCEPTION, "get_player_info: player %d not found", player_id);

  player->player_id = player_id;
  player->name = db_result_get_string(result, "name");
  player->tribe = db_result_get_string(result, "tribe");
  player->max_caves = db_result_get_int(result, "takeover_max_caves");
  player->locale = db_result_get_string(result, "language");
  player->locale_id = get_locale_id(player->locale);
  get_science_list(result, player->science);
}

int ul_db_query(str * table, str * first, str * second, db1_con_t *** _r_h, 
				db_key_t* _k, db_op_t* _op,	db_val_t* _v,
                db_key_t* _c, int _n, int _nc,	db_key_t _o, db1_res_t** _r) {
	ul_db_handle_t * handle;
	db_func_t * f;
	int ret;
	if((handle = get_handle(&mdb.read.dbf, mdb.read.dbh, first, second)) == NULL) {
		LM_ERR("could not retrieve db handle.\n");
		return -1;
	}
	if((ret = db_query(handle, _r_h, &f, table, _k, _op, _v, _c, _n, _nc, _o, _r, db_master_write)) < 0){
		return ret;
	}
	add_dbf(*_r, f);
	return ret;
}

bool DBPermObj::AddToWhitelist(std::string & dbuser, std::string & pattern)
{
    char * q = new char [ pattern.length() + 1024 ];
    db_struct db;

    snprintf(q, pattern.length() + 1024,
        "SELECT queryid FROM query WHERE "
        "proxyid = %d and db_name = '%s' and query = '%s'",
        proxy_id, db_name.c_str(), pattern.c_str());

    /* read new queryid from the database */
    if (! db_query(&db, q ,pattern.length() + 1024)) {
        /* Failed */
        logevent(STORAGE,"DB config erorr: %s\n",db_error());
        delete [] q;
        db_cleanup(&db);
        return false;
    } 

    /* Download result from server */
    if (db_fetch_row(&db))
    {
        // nothing to do here, query is aready in whitelist
        delete [] q;
        db_cleanup(&db);
        return true;
    }

    // add pattern to the whitelist
    snprintf(q, pattern.length() + 1024,
       "INSERT into query "
       "(proxyid, perm, db_name, query) "
       "VALUES (%d,1,'%s','%s')",
       proxy_id, db_name.c_str(), pattern.c_str());

    /* read new urls from the database */
    if (! db_exec(q)) {
        /* Make query */
        logevent(STORAGE,"DB config erorr: %s\n",db_error());
        delete [] q;
        return false;
    }
    delete [] q;
    q = NULL;

    return true;
}

int do_migrate(int migrate_limit)
{
	C c; R r;
	int id = 0;
	int count = 0;
	DbmailMessage *m;
	
	qprintf ("Mirgrate legacy 2.2.x messageblks to mimeparts...\n");
	if (!yes_to_all) {
		qprintf ("\tmigration skipped. Use -y option to perform mirgration.\n");
		return 0;
	}
	qprintf ("Preparing to migrate %d physmessages.\n", migrate_limit);

	c = db_con_get();
	TRY
		r = db_query(c, "SELECT DISTINCT(physmessage_id) FROM %smessageblks LIMIT %d", DBPFX, migrate_limit);
		qprintf ("Migrating %d physmessages...\n", migrate_limit);
		while (db_result_next(r))
		{
			count++;
			id = db_result_get_u64(r,0);
			m = dbmail_message_new();
			m = dbmail_message_retrieve(m, id, DBMAIL_MESSAGE_FILTER_FULL);
			if(!dm_message_store(m))
			{
				if(verbose) qprintf ("%d ",id);
				db_update("DELETE FROM %smessageblks WHERE physmessage_id = %d", DBPFX, id);
			}
			else
			{
				if(!verbose) qprintf ("migrating physmessage_id: %d\n",id);
				qprintf ("failed\n");
				return -1;
			}
			dbmail_message_free(m);
		}
	CATCH(SQLException)
		LOG_SQLERROR;
		return -1;
	FINALLY
		db_con_close(c);
	END_TRY;
	
	qprintf ("Migration complete. Migrated %d physmessages.\n", count);
	return 0;
}

/* serv should be db_escape'd before call */
int db_getserver(char *serv)
{
#ifdef HASHLISTSUPPORT
	strtolwr(serv);
	return hash_find(hashservs, serv, KEYOTHER);
#else
	MYSQL_RES *resptr;
	int res = 0;

	db_query("SELECT servid FROM " TBL_SERV " WHERE server=\'%s\'", serv);
	resptr = mysql_store_result(myptr);
	if (mysql_num_rows(resptr))
		res = atoi(*mysql_fetch_row(resptr));
	mysql_free_result(resptr);
	return res;
#endif
}

/*
 * Retrieve monster table information for the given monster id.
 */
void get_monster_info (db_t *database, int monster_id, struct Monster *monster)
{
  db_result_t *result = db_query(database,
	"SELECT * FROM Monster WHERE monsterID = %d", monster_id);

  if (!db_result_next_row(result))
    throwf(SQL_EXCEPTION, "get_monster_info: monster %d not found", monster_id);

  monster->monster_id = monster_id;
  monster->name = db_result_get_string(result, "name");
  monster->attack = db_result_get_int(result, "angriff");
  monster->defense = db_result_get_int(result, "verteidigung");
  monster->mental = db_result_get_int(result, "mental");
  monster->strength = db_result_get_int(result, "koerperkraft");
  monster->exp_value = db_result_get_int(result, "erfahrung");
  monster->attributes = db_result_get_string(result, "eigenschaft");
}

t_max_err db_query_silent(t_database *db, t_db_result **dbresult, const char *s, ...)
{
	char		sql[DATABASE_SQL_MAXLEN+2];
	va_list		ap;
	long		logging = false;
	t_max_err	err;

	va_start(ap, s);
	vsnprintf(sql, DATABASE_SQL_MAXLEN, s, ap);
	sql[DATABASE_SQL_MAXLEN] = '\0';

	logging = object_attr_getlong(db, _sym_log);
	object_attr_setlong(db, _sym_log, 0);
	err = db_query(db, dbresult, sql, NULL);
	object_attr_setlong(db, _sym_log, logging);
	return err;
}

long CDataObject::GetData(CDatabase* p_db)
{
	/*
		Fills the data array and returns the number of points inserted
	*/

	assert(m_br >= ePreflopIndex && m_br < eRoundIndices);
	assert(m_nacted >= 0);

	std::string query_str = CDatabaseInterface::ConstructSelectQueryString(m_br, m_nacted, m_ndealt, m_action);

	//p_db->CheckDB(br_ndx, times_acted);
	CDatabaseQuery db_query(p_db);
	db_query.Select(query_str.c_str());

	// Get the actual values
	for(int p = 0; p < db_query.get_numrows(); p++)
	{
		// save address for ann
		m_data[p] = m_points.row(p).data();
		// save hand_id
		m_hand_ids[p] = atoi(PQgetvalue(db_query.get_pgresult(), p, 0));
		// FIX ME - profit should be a part of the select query
		bool profit_ok = CDatabaseInterface::GetProfit(m_hand_ids[p], m_profits(p), p_db);

		// prefix every row with 1's for teh intercept
		m_points(p, 0) = 1.0;
		for(int column = 1; column < db_query.get_numcolumns(); column++)
		{
			double tmp = atof(PQgetvalue(db_query.get_pgresult(), p, column));
			m_points(p, column) = tmp;
		}

		#if defined DEBUG_ALIGN
			if(row < 10)
			{
				double progress_percent = ((m_npoints > 0) ? ((100.0 * (row+1))/m_npoints) : 0.0);
				gLog.WriteLogNoHeading(eSeverityInfo, eCatANN, "Data Point : %d/%d [%.2lf %%] - %s\n", 
														row+1, m_npoints, progress_percent, PrintPtStr(m_points.row(row).data(), m_ndims).c_str());
			}
		#endif
	}

	return db_query.get_numrows();
}

/*
 * Retrieve relation table information for the given tribe and tribe_target.
 */
int get_relation_info (db_t *database, const char *tribe,
		       const char *tribe_target, struct Relation *relation)
{
  db_result_t *result = NULL;

  if (tribe && tribe_target)
  {
    debug(DEBUG_BATTLE, "get relation for tribes %s %s", tribe, tribe_target);
    result = db_query(database,
	"SELECT * FROM " DB_TABLE_RELATION
	" WHERE tribe = '%s' AND tribe_target = '%s'", tribe, tribe_target);
  }

  if (!result || !db_result_next_row(result))
  {
    debug(DEBUG_BATTLE, "filling dummy relation");
    relation->relation_id = 0;
    relation->tribe = tribe;
    relation->tribe_target = tribe_target;
    relation->relationType = RELATION_TYPE_NONE;

    /* FIXME these values should be read from relation types */
    relation->attackerMultiplicator = 0.5;
    relation->defenderMultiplicator = 1.0;
    relation->attackerReceivesFame = 0;
    relation->defenderReceivesFame = 0;

    return 0;	/* no relation entry */
  }

  relation->relation_id = db_result_get_int(result, "relationID");
  relation->tribe = tribe;
  relation->tribe_target = tribe_target;
  relation->relationType = db_result_get_int(result, "relationType");
  relation->defenderMultiplicator =
    db_result_get_double(result, "defenderMultiplicator");
  relation->attackerMultiplicator =
    db_result_get_double(result, "attackerMultiplicator");
  relation->defenderReceivesFame =
    db_result_get_int(result, "defenderReceivesFame");
  relation->attackerReceivesFame =
    db_result_get_int(result, "attackerReceivesFame");

  return 1;
}

void *reset(void *dummy) {
	while(1) {
		// waiting user input
		getchar();
		split();

		// reset black color
		bkgd(COLOR_PAIR(2));
		refresh();

		newmessage = 0;
		
		// mark all as read
		db_query(db, "UPDATE notifications SET read = 1");
	}
	
	return dummy;
}

GList * auth_get_known_aliases(void)
{
	GList * aliases = NULL;
	C c; R r;

	c = db_con_get();
	TRY
		r = db_query(c,"SELECT alias FROM %saliases ORDER BY alias",DBPFX);
		while (db_result_next(r))
			aliases = g_list_append(aliases, g_strdup(db_result_get(r,0)));
	CATCH(SQLException)
		LOG_SQLERROR;
	FINALLY
		db_con_close(c);
	END_TRY;
	
	return aliases;
}

GList * auth_get_known_users(void)
{
	GList * users = NULL;
	C c; R r; 

	c = db_con_get();
	TRY
		r = db_query(c, "SELECT userid FROM %susers ORDER BY userid",DBPFX);
		while (db_result_next(r)) 
			users = g_list_append(users, g_strdup(db_result_get(r, 0)));
	CATCH(SQLException)
		LOG_SQLERROR;
	FINALLY
		db_con_close(c);
	END_TRY;
	
	return users;
}

t_sfilter *sfilter_get( int id )
{
	PGresult *res;
	t_sfilter *t;

	res = db_query( "SELECT id, name, filter "
			"FROM juke_sfilter WHERE id = %d",id);
	if( ! res || PQresultStatus(res) != PGRES_TUPLES_OK ){
		syslog( LOG_ERR, "sfilter_get: %s", db_errstr());
		PQclear(res);
		return NULL;
	}

	t = sfilter_convert(res, 0 );
	PQclear(res);

	return t;
}

static int map_get_bounds (db_t *database,
         int *minX, int *maxX, int *minY, int *maxY)
{
  db_result_t *result = db_query(database,
    "SELECT MIN(xCoord) AS minX, "
    "       MAX(xCoord) AS maxX, "
    "       MIN(yCoord) AS minY, "
    "       MAX(yCoord) AS maxY  "
    "FROM Cave");

  if (!db_result_next_row(result)) return 0;

  *minX = db_result_get_int(result, "minX");
  *maxX = db_result_get_int(result, "maxX");
  *minY = db_result_get_int(result, "minY");
  *maxY = db_result_get_int(result, "maxY");
  return 1;
}

/*
 * Retrieve artefact for the given id.
 */
void get_artefact_by_id (db_t *database, int artefactID,
			 struct Artefact *artefact)
{
  db_result_t *result =
    db_query(database, "SELECT * FROM " DB_TABLE_ARTEFACT
		       " WHERE artefactID = %d", artefactID);

  /* Bedingung: Artefakt muss vorhanden sein */
  if (db_result_num_rows(result) != 1)
    throw(SQL_EXCEPTION, "get_artefact_by_id: no such artefactID");

  db_result_next_row(result);

  artefact->artefactID      = artefactID;
  artefact->artefactClassID = db_result_get_int(result, "artefactClassID");
  artefact->caveID          = db_result_get_int(result, "caveID");
  artefact->initiated       = db_result_get_int(result, "initiated");
}