xoonips/AL/commonal.cc

/*
 * --------------------------------------------------------------------------  
 * XooNiPs Xoops modules for Neuroinformatics Platforms                        
 * Copyright (C) 2005 RIKEN, Japan. All rights reserved.                       
 * http://sourceforge.jp/projects/xoonips/                                     
 * --------------------------------------------------------------------------  
 * This program is free software; you can redistribute it and/or               
 * modify it under the terms of the GNU General Public License                 
 * as published by the Free Software Foundation; either version 2              
 * of the License, or (at your option) any later version.                      
 *                                                                             
 * This program is distributed in the hope that it will be useful,             
 * but WITHOUT ANY WARRANTY; without even the implied warranty of              
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               
 * GNU General Public License for more details.                                
 *                                                                             
 * You should have received a copy of the GNU General Public License           
 * along with this program; if not, write to the Free Software                 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
 * --------------------------------------------------------------------------  
 * 
 * 
 * $Revision: 1.112 $
 * $Log: commonal.cc,v $
 * Revision 1.112  2005/10/07 06:22:46  aga4096
 * 鐃緒申updateAccount()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.111  2005/09/26 02:24:34  aga4096
 * 鐃緒申isAdmin()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.110  2005/09/09 06:26:35  aga4096
 * 鐃緒申xnp_use_syslog()鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.109  2005/09/09 01:29:27  aga4096
 * 鐃緒申refresh_item_status, update_item_status鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.108  2005/09/08 05:40:21  tani
 * freeStringArray鐃緒申鐃緒申鐃緒申.
 * selectiveHarvesting鐃緒申OAIPMH鐃緒申identifier鐃緒申鐃緒申鐃緒申.
 * XNP_CONFIG_REPOSITORY_NIJC_CODE鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.107  2005/08/30 09:39:31  aga4096
 * 鐃緒申xnp_get_item_status 鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.106  2005/08/29 07:11:05  aga4096
 * 鐃緒申xnp_update_item_status, xnp_selective_harvesting鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.105  2005/08/29 05:27:37  aga4096
 * 鐃緒申update_item_status鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.104  2005/08/29 02:05:34  aga4096
 * 鐃緒申xnp_update_item_status(), xnp_refresh_item_status(), xnp_selective_harvesting() 鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.103  2005/08/23 07:34:24  tani
 * Language鐃緒申鐃緒申: getItems, _insetItem, updateItem
 *
 * Revision 1.102  2005/08/23 02:19:10  tani
 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.101  2005/08/08 01:57:00  aga4096
 * 鐃緒申2鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申initializeDB鐃緒申鐃緒申鐃緒申.
 * 鐃緒申valgrind鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.100  2005/07/21 01:47:57  tani
 * getEventsForRSS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.99  2005/07/15 04:42:33  aga4096
 * 鐃緒申getItemTypes鐃緒申鐃緒申DB鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.98  2005/07/12 06:40:44  aga4096
 * 鐃緒申setConfigValue鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.97  2005/06/30 07:21:42  aga4096
 * 鐃緒申get_all_index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.96  2005/06/29 00:10:18  aga4096
 * 鐃緒申login name -> additional info 鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.95  2005/06/24 02:07:34  tani
 * insertItemDirect鐃緒申鐃緒申鐃緒申(Import鐃緒申)
 * getPrivateItemID鐃緒申鐃緒申BINDER鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
 *
 * Revision 1.94  2005/06/23 07:58:12  aga4096
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.93  2005/06/14 01:02:20  aga4096
 * 鐃緒申鐃緒申鐃緒申Binder鐃緒申鐃緒申鐃緒申鐃緒申. xnp_extract_public_item_id, xnp_extract_nonbinder_item_id 鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.92  2005/06/08 04:27:08  tani
 * default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.91  2005/06/07 01:10:33  tani
 * SQLGetData鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQLExecute鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.90  2005/05/23 08:00:30  tani
 * insertGroup, updateGroup: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.89  2005/05/18 10:00:17  aga4096
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.88  2005/03/17 16:02:40  orrisroot
 * UNIX 鐃緒申鐃緒申鐃緒申鐃緒申 SQLLEN 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申configure
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 config.h 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 MacOS X 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *
 * Revision 1.87  2005/03/15 12:09:39  tani
 * deleteItem 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.86  2005/03/15 04:49:40  tani
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.85  2005/03/14 09:30:50  aga4096
 * 鐃緒申getItemCountByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.84  2005/03/14 06:12:11  tani
 * __BORLANDC__鐃緒申鐃緒申.
 *
 * Revision 1.83  2005/03/11 20:00:28  orrisroot
 * - Autotoolized XooNiPs Abstract Layer projects.
 * - changelog.cc commonal.cc index.cc item.cc :
 *     included <time.h> header file for undefined data type 'time_t' error.
 *
 * Revision 1.82  2005/03/11 07:11:30  tani
 * itemid_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(*iidsLen)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.81  2005/03/11 00:34:57  tani
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申certify_state鐃緒申鐃緒申.
 *
 * Revision 1.80  2005/03/09 07:27:37  aga4096
 * 鐃緒申activate=0鐃緒申鐃緒申loginUser鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.79  2005/03/07 01:20:09  aga4096
 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.78  2005/03/05 02:28:05  aga4096
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 Private 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.77  2005/03/05 01:48:35  aga4096
 * 鐃緒申getItemCountGroupByIndex鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.76  2005/03/04 06:13:28  aga4096
 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.75  2005/03/03 10:13:00  aga4096
 * 鐃緒申isValidSession鐃緒申timestamp鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申session鐃緒申isValidSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申loginUser, createSession鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.74  2005/02/26 05:11:31  tani
 * getGroupItemID鐃緒申鐃緒申.
 *
 * Revision 1.73  2005/02/25 07:41:35  tani
 * getGroupItemID鐃緒申鐃緒申.
 * item, index鐃緒申limit鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.72  2005/02/25 01:03:42  tani
 * dbtype==DBTYPE_SQLITE鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.71  2005/02/24 11:32:55  aga4096
 * 鐃緒申updateGroup鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.70  2005/02/23 06:39:28  tani
 * isGuestEnabled: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.69  2005/02/22 02:39:30  tani
 * public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * SQL鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申public_item_target_user_all鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * session鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申LEFT JOIN鐃緒申鐃緒申鐃緒申鐃緒申sid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.68  2005/02/21 05:46:18  tani
 * getItemCount鐃緒申鐃緒申鐃緒申.
 * dumpItemID, getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.67  2005/02/19 02:06:11  tani
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.66  2005/02/16 10:03:13  youi
 * publication_year/month/mday鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.65  2005/02/16 07:37:17  youi
 * insertItem, updateItem, getItems: publication_date鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.64  2005/02/15 02:35:47  youi
 * SQLINTEGER鐃緒申鐃緒申SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.63  2005/02/10 02:33:16  aga
 * 鐃緒申zipCreate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.62  2005/02/09 11:11:52  youi
 * deleteItem鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.61  2005/02/09 07:23:50  aga
 * 鐃緒申URL to My Personal Archive 鐃緒申DB鐃緒申AL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.60  2005/02/09 02:14:15  aga
 * 鐃緒申initializeDB()鐃緒申dbtype鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(SQLite鐃緒申).
 *
 * Revision 1.59  2005/02/08 07:15:02  youi
 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申:
 *
 * Revision 1.58  2005/02/08 06:40:51  youi
 * pubmedComplete:鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申pubmed_t鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.57  2005/02/03 12:04:58  youi
 * getOwnPublicItemID鐃緒申鐃緒申鐃緒申.
 * binder_item_link鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.56  2005/01/29 09:49:22  youi
 * syslog_printf: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * getCertifyPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申sql鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * SQLINTEGER->SQLLEN鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * getItemPermission: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.55  2005/01/28 07:01:38  youi
 * getItemIDByIndexID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * SQLAllocHandle鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.54  2005/01/28 00:36:58  aga
 * 鐃緒申freeString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.53  2005/01/27 08:30:35  youi
 * getIndexIDByItemID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.52  2005/01/25 06:46:50  aga
 * 鐃緒申Binders鐃緒申鐃緒申鐃緒申index鐃緒申deleteIndex鐃緒申鐃緒申.
 * 鐃緒申getItems鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.51  2005/01/24 10:50:29  youi
 * freeItemType,getItemTypes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.50  2005/01/24 01:54:38  youi
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *  dumpItemID, getItemIDByBinderID, getItemIDByIndexID
 * 鐃緒申鐃緒申鐃緒申鐃緒申
 *  getPrivateItemID, getUncertifiedLink
 *
 * Revision 1.49  2005/01/22 09:30:58  youi
 * setLastErrorString鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.48  2005/01/22 04:18:22  aga
 * 鐃緒申loginUser, insertAccount鐃緒申鐃緒申鐃緒申md5()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.47  2005/01/22 02:41:14  aga
 * 鐃緒申amazon鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.46  2005/01/21 01:36:11  youi
 * pubmed鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.45  2005/01/19 10:07:53  aga
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.44  2005/01/19 06:01:59  youi
 * 鐃緒申鐃緒申鐃緒申鐃緒申
 *  getConfigValue
 *  setConfigValue
 *  getChangeLogs
 *  insertChangeLog
 *  getItemIDByBinderID
 *  registerBinderItem
 *  unregisterBinderItem
 *  getIndexPermission
 *  freeString
 *  freeChangeLog
 * 鐃緒申鐃緒申鐃緒申criteria_t鐃緒申鐃緒申鐃緒申
 *  getItemIDByIndexID
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *  getCertifyState
 *  setCertifyState
 *  getCertifyPermission
 * sessionID2UID,querySimple,queryGetUnsignedInt鐃緒申鐃緒申鐃緒申
 * insertItem鐃緒申鐃緒申鐃緒申鐃緒申PrivateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * getItems: getItemPermission鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.43  2005/01/19 01:42:15  aga
 * 鐃緒申x_xoonips_index鐃緒申gid,uid鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.42  2005/01/19 00:51:29  aga
 * 鐃緒申insertIndex鐃緒申x_xoonips_index.index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.41  2005/01/19 00:06:51  aga
 * 鐃緒申updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申createSession鐃緒申鐃緒申uid鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.40  2005/01/17 00:15:05  aga
 * 鐃緒申deleteIndex, updateIndex鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.39  2005/01/15 05:38:10  youi
 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * updateAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *     insertItem, getItem, getItems, dumpItemID, updateItem, deleteItem鐃緒申鐃緒申.
 * freeGID, freeUID: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.38  2005/01/15 00:39:16  aga
 * 鐃緒申x_xoonips_item_basic鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.37  2005/01/14 10:36:59  aga
 * 鐃緒申index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申insertAccount鐃緒申private index鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申insertGroup鐃緒申group index 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.36  2005/01/13 04:19:22  aga
 * 鐃緒申VP鐃緒申XNP鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.35  2005/01/06 07:20:17  youi
 * WIN32鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * MySQL API鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * deleteAccount: 鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * insertAccount: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * deleteMember: 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * deleteMemberNoLimit鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.34  2004/12/28 04:38:14  aga
 * 鐃緒申logoutUser()鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.33  2004/12/27 05:56:23  youi
 * odbcDiagString: STMT鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * syslog鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.32  2004/12/25 09:46:47  youi
 * MySQL+MyODBC鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.31  2004/12/21 11:42:59  youi
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.30  2004/12/18 10:24:54  youi
 * IMPORT_MYSQLDLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申MYSQL鐃緒申DLL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.29  2004/12/18 01:12:29  youi
 * freeResult鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申free<鐃緒申鐃緒申鐃緒申鐃緒申>鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.28  2004/12/14 12:02:08  youi
 * __WIN__鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申windows鐃緒申dll鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * USE_SYSLOG鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申syslogd鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * getAccounts: uidsLen鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.27  2004/12/06 11:34:47  aga
 * 鐃緒申uninitializeDB()鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.26  2004/12/06 10:17:36  youi
 * mysql_use_result鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * while( row = mysql_fetch_row(result) );鐃緒申鐃緒申鐃緒申鐃緒申
 *
 * Revision 1.25  2004/12/06 07:24:33  youi
 * insertAccount, insertGroup:
 *     鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.24  2004/12/06 01:45:50  aga
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.23  2004/12/04 09:21:10  aga
 * 鐃緒申xnp_config 鐃緒申 xoonips_config.
 *
 * Revision 1.22  2004/12/03 07:17:21  youi
 * isModerator鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.21  2004/12/01 10:28:58  youi
 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *     institute -> division
 *     organizaion -> company_name
 *
 * Revis1.20  2004/12/01 04:37:04  youi
 * freeResult: unsigned int* 鐃緒申 int* 鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.19  2004/11/30 06:40:11  youi
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(gidExists, uidExists)
 * getGroupCount鐃緒申鐃緒申鐃緒申.
 * getGroupsByUid鐃緒申鐃緒申鐃緒申.
 * isGroupAdmin鐃緒申鐃緒申鐃緒申.
 * dumpGroupAdmins鐃緒申鐃緒申鐃緒申.
 * deleteMember鐃緒申鐃緒申鐃緒申.
 * insertMember鐃緒申鐃緒申鐃緒申.
 * getMembers鐃緒申鐃緒申鐃緒申.
 * isModerator鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.18  2004/11/30 05:46:32  aga
 * 鐃緒申session鐃緒申鐃緒申remoteHost鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.17  2004/11/27 09:35:49  youi
 * isActivated鐃緒申鐃緒申鐃緒申.
 * activate鐃緒申鐃緒申鐃緒申.
 * dumpUid鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.16  2004/11/27 06:29:29  youi
 * getAccountCount鐃緒申鐃緒申鐃緒申.
 * dumpGids鐃緒申鐃緒申鐃緒申.
 * insertGroup, deleteGroup, updateGroup鐃緒申鐃緒申鐃緒申.
 * getGroup, getGroups鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申RES_DB_NOT_INITIALIZED鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * (鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)
 *
 * Revision 1.15  2004/11/27 02:22:22  aga
 * 鐃緒申initializeDB鐃緒申鐃緒申addSlashes()鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.14  2004/11/27 01:07:31  youi
 * criteria2str: LIMIT鐃緒申ORDER BY鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.13  2004/11/27 00:35:39  youi
 * getAccounts鐃緒申鐃緒申鐃緒申.
 * getAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getAccounts鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * criteria2str鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.12  2004/11/26 09:45:28  youi
 * getAccount鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.11  2004/11/26 08:16:26  aga
 * 鐃緒申getSession, loginUser, createSession, freeResult(const session_t*) 鐃緒申鐃緒申.
 *
 * Revision 1.10  2004/11/26 07:57:42  youi
 * updateAccount, deleteAccount鐃緒申鐃緒申鐃緒申.
 * mysql_query鐃緒申鐃緒申鐃緒申鐃緒申stderr鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.9  2004/11/26 07:38:02  aga
 * 鐃緒申FAILUE -> FAILURE.
 *
 * Revision 1.8  2004/11/26 06:36:55  aga
 * 鐃緒申createSession, getSession 鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.7  2004/11/26 04:51:47  youi
 * dbprefix鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * insertAccount鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * isValidSessionID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.6  2004/11/26 04:35:55  aga
 * 鐃緒申loginUser(), logoutUser()鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.5  2004/11/26 01:08:25  aga
 * 鐃緒申addSlashes()鐃緒申鐃緒申.
 *
 * Revision 1.4  2004/11/25 12:14:29  youi
 * getUid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.3  2004/11/25 11:13:59  youi
 * getLastErrorString/setLastErrorString鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.2  2004/11/25 08:55:19  youi
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * freeResult鐃緒申鐃緒申鐃緒申.
 *
 * Revision 1.1  2004/11/25 05:14:58  youi
 * initial version
 *
 * 
 */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef WIN32
#include <windows.h>
#endif

#ifdef USE_SYSLOG
#include <syslog.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <assert.h>
#include <time.h>
#include <sql.h>
#include <sqlext.h>
#include <libxml/xmlreader.h>

using namespace std;

#include "common.h"
#include "account.h"
#include "group.h"
#include "session.h"
#include "item.h"
#include "itemtype.h"
#include "criteria.h"
#include "commonal.h"
#include "item.h"
#include "index.h"
#include "changelog.h"
#include "pubmed.h"
#include "amazonbook.h"

static string dbprefix; //!< XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
static dbtype_t dbtype; //!< MySQL/SQLite
static bool useSyslogFlag = false;

static SQLHANDLE henv = NULL;
static SQLHANDLE hdbc = NULL;


static bool processEsummary(xmlTextReaderPtr reader, pubmed_t* p);
static bool processEsearch(xmlTextReaderPtr reader, pubmed_t* p, int* DocID );
static void processEfetch(xmlTextReaderPtr reader, pubmed_t* p);
static int streamPubmedFile(const char *filename, pubmed_t* p);
static result_t insertIndexInternal( sessionid_t sid, index_t *index, indexid_t *xid );
static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode );
static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid );
static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value );
static void setLastErrorString( const char* str );
static result_t checkTitleConflict( sessionid_t sid, indexid_t parentIndexID, const char *title, bool *conflict );
static result_t _insertItem( sessionid_t sid, const item_t* item, itemid_t* itemid, bool direct );
static result_t getEvents(sessionid_t sid, event_t** events, int* eventsLen, string condition );
static result_t insertMetadataEvent( metadataevent_t me, itemid_t iid );
static result_t insertMetadataEventAuto( itemid_t iid, bool isCreate = false );

static void syslog_printf( char* format, ... )
{
#ifdef USE_SYSLOG
    if ( useSyslogFlag ){
        va_list ap;
        va_start(ap, format);
        openlog( "commonal", LOG_ODELAY, LOG_USER );
        vsyslog( LOG_DEBUG, format, ap );
    }
#endif
}

void useSyslog( bool f )
{
    useSyslogFlag = f;
}

/**  ',' . implode( ',', pi ) 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申comma鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param pi   int鐃緒申鐃緒申
 * @param len  鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 */
static string getCsvStr( const itemid_t *pi, int len ){
    char *buf = new char[(sizeof(int)*3+1)*len+1];
    buf[0] = '\0';
    char *p = buf;
    for ( int i = 0; i < len; i++ ){
        int len = sprintf( p, ",%u", pi[i] );
        p += len;
    }
    string iids_str(buf);
    delete[] buf;
    return iids_str;
}

/**
 * 
 * public_item_target_user鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申true鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申'all'鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
static bool public_item_target_user_all( )
{
    char* value = 0;
    bool public_item_target_user_all = false;
    if( getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value ) == RES_OK ){
        public_item_target_user_all = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
        freeString( value );
    }
    return public_item_target_user_all;
}

static result_t countResultRows( const char* sql, SQLLEN* count )
{
    result_t ret = RES_ERROR;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql, strlen( sql ) ) ) == SQL_SUCCESS ){
            *count = 0;
            while( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ) ( *count )++;
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in countResultRows " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    return ret;
}


/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
static certify_t getInitialCertifyStateFromConfig( )
{
    char* certify_item_val;
    certify_t ret = index::NOT_CERTIFIED;
    
    if( getConfigValue( XNP_CONFIG_CERTIFY_ITEM_KEY, &certify_item_val ) == RES_OK ){
        if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_AUTO ) == 0 ){
            //certify automatic
            ret = index::CERTIFIED;
        }else if( strcmp( certify_item_val, XNP_CONFIG_CERTIFY_ITEM_ON ) == 0 ){
            //certify by moderator or group admin
            ret = index::CERTIFY_REQUIRED;
        }
        syslog_printf( "\ngetInitialCertifyStateFromConfig certify_item_val=%s", certify_item_val );
        freeString( certify_item_val );
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申Activate鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return true Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false Activate鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *
 */
static bool isActivatedBySession( sessionid_t sid )
{
    const session_t* session;
    if( getSession( sid, &session ) == RES_OK ){
        userid_t sess_uid = session ->  getUID( );
        freeSession( session );
        return isActivated( sid, sess_uid );
    }
    return false;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 *
 */
static bool isModeratorBySession( sessionid_t sid )
{
    const session_t* session;
    if( getSession( sid, &session ) == RES_OK ){
        userid_t sess_uid = session ->  getUID( );
        freeSession( session );
        return isModerator( sid, sess_uid );
    }
    return false;
}


// SQLAllocHandle鐃緒申SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申hstmt鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
class sqlexec_t {
private:
    SQLRETURN sqlcode;
    SQLHANDLE hstmt;
public:
    SQLRETURN getSqlcode(){ return sqlcode; }
    SQLHANDLE getHstmt(){ return hstmt; }
    //SQLRETURN SQLFetch(){ return sqlcode = SQLFetch(hstmt); } // 鐃緒申鐃緒申鐃緒申wrapper鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    
    /** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申: SQLAllocHandle, SQLExecDirect鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申getSqlcode()==SQL_SUCCESS
     * @param functionName 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
     * @param sql 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申SQL
     * @param ret 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
     */
    sqlexec_t( const char *functionName, string &sql, result_t *ret ){
        sqlcode = 0;
        hstmt = 0;
        
        if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
            if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
                return;
            }else {
                string s( "SQLExecDirect in  " );
                s += functionName;
                s += " ";
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += " sql=";
                s += string( sql );
                setLastErrorString( s.c_str( ) );
                *ret = RES_DB_QUERY_ERROR;
                return;
            }
        }else {
            string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in " );
            s += functionName;
            s += " ";
            s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
            setLastErrorString( s.c_str( ) );
            *ret = RES_ERROR;
            return;
        }
    }
    ~sqlexec_t(){
        if ( hstmt )
            SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
};


/** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @param sql sql
  * @return result_t
  */
static result_t querySimple( const char *functionName, string &sql ){
    result_t ret = RES_ERROR;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in querySimple " );
            s += functionName;
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += sql;
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    else {
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in querySimple " );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/** SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申1鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(NULL鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @param sql sql
  * @param u   鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @return result_t
  */
static result_t queryGetUnsignedInt( const char *functionName, string &sql, unsigned int *u ){
    result_t ret = RES_ERROR;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;

    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
            SQLUINTEGER sInt = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &sInt, 0, &len );
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                if ( len == SQL_NULL_DATA )
                    sInt = 0;
                *u = sInt;
                ret = RES_OK;
            }else{
                string s( "SQLFetch in queryGetUnsignedInt " );
                s += functionName;
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_ERROR;
            }
        }else{
            string s( "SQLExecDirect in queryGetUnsignedInt " );
            s += functionName;
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += sql;
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    else {
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in queryGetUnsignedInt " );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * ( dst鐃緒申鐃緒申鐃緒申鐃緒申 >= len + 1 )鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
static char* strncpy2( char* dst, const char* src, int len )
{
    strncpy( dst, src, len );
    dst[ len ] = '\0';
    syslog_printf( "\nstrncpy2 '%s'\n", dst );
    return dst;
}

/**
 * 
 * SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param hstmt SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param sqlcode SQLExecDirect,SQLExecute鐃緒申鐃緒申鐃緒申鐃緒申
 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 */
static string odbcDiagString( SQLSMALLINT HandleType, SQLHANDLE hstmt, SQLRETURN sqlcode )
{
    string s;
    if( sqlcode == SQL_ERROR || sqlcode == SQL_SUCCESS_WITH_INFO ){
        SQLCHAR SQLState[6];
        SQLINTEGER NativeError;
        SQLCHAR MessageText[ 1024 ];
        SQLSMALLINT TextLength;
        SQLGetDiagRec( HandleType, hstmt, 1, SQLState, &NativeError, MessageText, 1024, &TextLength );
        
        s += string( (char*)MessageText );
        s += " SQLSTATE=";
        s += string( (char*)SQLState );
        
    }
    s += " sqlcode=";
    s += intToString( sqlcode );
    return s;
}

/** 
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
string getResultCol( SQLHANDLE hstmt, int col, SQLSMALLINT targetType = SQL_C_CHAR )
{
    string s;
    SQLRETURN  sqlcode;
    SQLCHAR    BinaryPtr[5000];
    SQLLEN     BinaryLenOrInd;
    SQLINTEGER NumBytes;
    
    syslog_printf( "getResultCol" );
    while ( ( sqlcode = SQLGetData(hstmt, col, targetType, BinaryPtr, sizeof(BinaryPtr),
                                   &BinaryLenOrInd)) != SQL_NO_DATA) {
        syslog_printf( "SQLGetData BinaryLenOrInd=%d", BinaryLenOrInd );
        NumBytes = (BinaryLenOrInd > 5000) || (BinaryLenOrInd == SQL_NO_TOTAL) ? 5000 : BinaryLenOrInd;
        if( NumBytes <= 0 ) break;
        else if( NumBytes > 0 ){
            s += string( (char*)BinaryPtr, NumBytes );
        }
    }
    syslog_printf( "getResultCol returns %s", s.c_str() );
    return s;
}


/** 
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申\鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param str addslashes鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申NULL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 */
string addSlashes( const char *str )
{
        if ( hdbc == NULL ){
                string s;
                return s;
        }else{
        string s( str );
        return s;
    }
    
        int len = strlen(str) * 3;
    char* dst = new char[ len ];
    const char* from = str;
    char* to = dst;
    while( *from != '\0' ){
        switch( *from ){
        case '\'':
        case '\"':
        case ';':
            *to = '\\'; to++;
            break;
        }
        *to = *from; to++;
        from++;
    }
    *to = '\0';
        string s( dst );
    delete[] dst;
        return s;
}

/** Xoops Module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @param module 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申dirname
  * @param key    鐃緒申鐃緒申鐃緒申key
  * @param value  鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @return 
  */
static result_t getXoopsModuleConfigValue( const char *module, const char *key, char **value ){
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    result_t result = RES_ERROR;
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql = "SELECT conf_value "
            " from " + dbprefix + "_config as tc, " + dbprefix  + "_modules as tm "
            " where tm.mid=tc.conf_modid and tm.dirname = ? and tc.conf_name = ? ";
        sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
        SQLLEN cbModule = SQL_NTS, cbKey = SQL_NTS;
        SQLBindParameter(hstmt,  1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(module), 0, (SQLCHAR *)module, 0, &cbModule );
        SQLBindParameter(hstmt,  2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, strlen(key),    0, (SQLCHAR *)key,    0, &cbKey );
        sqlcode = SQLExecute( hstmt );
        if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
            if ( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                string s = getResultCol( hstmt, 1 );
                *value = new char[s.length()+1];
                strcpy( *value, s.c_str() );
                result = RES_OK;
            }
            else if ( sqlcode == SQL_NO_DATA ){
                *value = 0;
                result = RES_OK;
            }
            else {
                string s( "SQLFetch in getXoopsModuleConfig " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += "sql=";
                s += sql;
                setLastErrorString( s.c_str( ) );
                result = RES_ERROR;
            }
        }else{
            string s( "SQLExecDirect in getXoopsModuleConfig " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += sql;
            setLastErrorString( s.c_str( ) );
            result = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    else {
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getXoopsModuleConfig " );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        result = RES_ERROR;
    }
    return result;
}

/** 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申Public鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  */
static bool isGuestEnabled(){
    char *value = 0;
    result_t result = getConfigValue( XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_KEY, &value );
    if ( result != RES_OK )
        return false;
    if ( value == 0 )
        return false;
    bool enabled = ( strcmp( value, XNP_CONFIG_PUBLIC_ITEM_TARGET_USER_ALL ) == 0 );
    freeString( value );
    return enabled;
}

/** sid鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
  * @param sid session id 
  * @param uid uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
  * @return RES_OK  
  *   sid鐃緒申鐃緒申鐃緒申鐃緒申sessionid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申
  *   鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申XooNiPs鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申 鐃緒申鐃緒申sid鐃緒申session::SID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uid鐃緒申鐃緒申account::UID_GUEST(=0)鐃緒申鐃緒申鐃緒申鐃緒申
  * @return 鐃緒申鐃緒申鐃緒申            鐃緒申鐃緒申鐃緒申
  */
static result_t sessionID2UID( sessionid_t sid, userid_t *uid ){
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    
    if ( sid == session::SID_GUEST ){
        if ( isGuestEnabled() ){
            *uid = account::UID_GUEST;
            return RES_OK;
        }
        return RES_NO_SUCH_SESSION;
    }
    else {
        string sql = "SELECT uid FROM " + dbprefix + "_xoonips_session WHERE sid=" + unsignedIntToString(sid);
        syslog_printf( "sql=%s", sql.c_str() );
        return queryGetUnsignedInt( "sessionID2UID", sql, uid );
    }
}


/**
 * 
 * gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申GID
 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
static bool gidExists( groupid_t gid )
{
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) != SQL_SUCCESS ) {
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in gidExists" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        return false;
    }

    sql = "SELECT * FROM " + dbprefix + "_xoonips_groups ";
    sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
    if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) != SQL_SUCCESS ){
        setLastErrorString( "SQLExecDirect in gidExists" );
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
        return false;
    }
    
    if( ( sqlcode = SQLFetch( hstmt ) ) != SQL_SUCCESS ){
        setLastErrorString( "SQLFetch in gidExists" );
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
        return false;
    }
    
    SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    return true;
}

    
/**
 * 
 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
static bool uidExists( userid_t uid )
{
    bool ret = false;
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    
    sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
    sql += "WHERE uid=" + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                ret = true;
            }else{
                string s( "SQLFetch in uidExists ");
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret = false;
            }
        }else{
            string s( "SQLExecDirect in uidExists ");
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += string( ", sql=" ) + string( sql );
            setLastErrorString( s.c_str( ) );
            ret = false;
        }
    }else{
        string s( "SQLAllocHandle in uidExists ");
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = false;
    }
    return ret;
}

    
/**
 * 
 * criteria 鐃緒申 SQL鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * 
 * 
 */
string criteria2str( criteria* cri )
{
    string sql;
    
    const orderby* odrby = cri -> headOrderBy( );
    if( odrby != 0 ){
        sql += " ORDER BY " + string( odrby -> getColumn( ) );
        sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
        while( ( odrby = cri -> nextOrderBy( ) ) != 0 ){
            sql += ", " + string( odrby -> getColumn( ) );
            sql += ( odrby -> getOrder( ) == orderby::DESC ) ? " DESC" : " ";
        }
    }

    if( cri -> getLimitStart( ) != 0 || cri -> getLimitRows( ) != 0 ){
        sql += " LIMIT " + string( intToString( cri -> getLimitStart( ) ) )
            + ", " + string( intToString( cri -> getLimitRows( ) ) );
    }
    return sql;
}


/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param dsn ODBC鐃緒申DSN
 * @param user 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param password 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param reserve 鐃緒申鐃緒申鐃緒申(NULL)
 * @param prefix XOOPS鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申PREFIX
 * @param type DBTYPE_MYSQL or DBTYPE_SQLITE
 * @return RES_OK
 * @return RES_DB_INITIALIZE_ERROR
 * @return RES_DB_CONNECT_ERROR
 * @see result_t
 */
result_t initializeDB( const char* dsn, const char* user, const char* password, const char* reserve, const char* prefix, dbtype_t type )
{
    SQLRETURN sqlcode;

    // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if ( hdbc != NULL ){
        SQLDisconnect( hdbc );
        hdbc = NULL;
    }
    
    dbprefix = prefix;
    dbtype = type;
    
    // 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
//    if( SQLAllocEnv( &henv ) != SQL_SUCCESS ) {
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv ) ) != SQL_SUCCESS ) {
        string s( "SQLAllocHandle(SQL_HANDLE_ENV,...) in initializeDB" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        syslog_printf( "initializeDB %s", getLastErrorString( ) );
        return RES_DB_INITIALIZE_ERROR;
    }
    //ODBC Ver.3 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); 
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_DBC, henv, &hdbc ) ) != SQL_SUCCESS ) {
        string s( "SQLAllocHandle(SQL_HANDLE_DBC,...) in initializeDB" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        syslog_printf( "initializeDB %s", getLastErrorString( ) );
        return RES_DB_INITIALIZE_ERROR;
    }
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申5鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    //SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)5, 0);
    
    if ( ( sqlcode = SQLConnect( hdbc, (SQLCHAR*)dsn, strlen( dsn ), (SQLCHAR*)user, strlen( user ), (SQLCHAR*)password, strlen( password ) ) ) != SQL_SUCCESS ){
        string s( "SQLConnect in initializeDB " );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        syslog_printf( "initializeDB %s", getLastErrorString( ) );
        return RES_DB_CONNECT_ERROR;
    }
    syslog_printf( "initializeDB succeed" );
    return RES_OK;
}

/**
 *
 * 鐃緒申鐃緒申DB鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param 鐃緒申鐃緒申
 * @return RES_OK
 */
result_t uninitializeDB()
{
    if ( hdbc != NULL ){
        SQLDisconnect( hdbc );
        hdbc = NULL;
    }
    return RES_OK;
}

/**
 * 
 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false 鐃緒申鐃緒申鐃緒申
 * 
 */
bool isActivated( sessionid_t sid, userid_t uid )
{
    if( hdbc == NULL ) return false;
    if( !isValidSessionID( sid ) ) return false;
    
    bool ret = false;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    
    sql = "SELECT * FROM " + dbprefix + "_xoonips_users ";
    sql += "WHERE activate=1 and uid=" + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                ret = true;
            }else{
                string s( "SQLFetch in isActivated " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += ", sql=" + sql;
                setLastErrorString( s.c_str() );
                ret = false;
            }
        }else{
            string s( "SQLExecDirect in isActivated " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=" + sql;
            setLastErrorString( s.c_str() );
            ret = false;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in isActivated" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = false;
    }
    return ret;
}

/**
 * 
 * Platform鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @param activate 鐃緒申鐃緒申(true) / 鐃緒申鐃緒申鐃緒申(false)鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_ERROR
 * @return RES_DB_QUERY_ERROR
 * @return RES_NO_SUCH_USER
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_NOT_INITIALIZED;
 */
result_t activate( sessionid_t sid, userid_t uid, bool activate )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    result_t ret = RES_ERROR;
    
    sql = "UPDATE " + dbprefix + "_xoonips_users ";
    sql += "SET activate=" + string( activate ? "1" : "0" );
    sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret = RES_OK;
            }else{
                string s( "SQLRowCount in activate ");
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_NO_SUCH_USER;
            }
        }else{
            string s( "SQLExecDirect in activate " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in activate" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申0)
 * 
 */
int getAccountCount( sessionid_t sid )
{
    if( hdbc == NULL ) return 0;
    if( !isValidSessionID( sid ) ) return 0;
    
    int ret = 0;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_users ";
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLUINTEGER count = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                ret = count;
            }else {
                string s( "SQLFetch in getAccountCount sql=" );
                s += string( sql );
                setLastErrorString( s.c_str( ) );
                ret = 0;
            }
        }else{
            setLastErrorString( "SQLExecDirect in getAccountCount" );
            ret = 0;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccountCount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = 0;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param 
 * @return RES_OK
 * @return RES_ERROR
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * 
 */
result_t deleteAccount( sessionid_t sid, userid_t uid )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;

    result_t ret1 = RES_ERROR, ret2 = RES_ERROR;
    criteria_t c;
    string sql;
    groupid_t* gids;
    int gidsLen;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    
    /*
      1. delete user from default platform group
      2. delete user profile from xoops_users
      3. delete platform user from xoonips_users
     */
    
    //1. delete user from platform groups
    c.clearAll();
    if( getGroupsByUid( sid, uid, &c, &gids, &gidsLen ) == RES_OK ){
        for( int i = 0; i < gidsLen; i++ )
            deleteMemberNoLimit( sid, gids[ i ], uid );
        freeGID( gids );
    }
    
    //2. delete user profile from xoops_users
    sql = "DELETE FROM " + dbprefix + "_users ";
    sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret1 = RES_OK;
            }else{
                string s( "SQLRowCount in deleteAccount" );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret1 = RES_NO_SUCH_USER;
            }
        }else{
            string s( "SQLExecDirect in deleteAccount" );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret1 = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret1 = RES_ERROR;
    }
    
    //3. delete platform user from xoonips_users
    sql = "DELETE FROM " + dbprefix + "_xoonips_users ";
    sql += "WHERE uid = " + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret2 = RES_OK;
            }else{
                string s( "SQLRowCount in deleteAccount" );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret2 = RES_NO_SUCH_USER;
            }
        }else{
            string s( "SQLExecDirect in deleteAccount" );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret2 = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret2 = RES_ERROR;
    }
    
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    return ret1 != RES_OK ? ret1 : ret2;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @param acc 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(account_t)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_USER
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @see freeAccount
 * 
 */
result_t getAccount( sessionid_t sid, userid_t uid, const account_t** acc )
{
    int len = 0;
    static criteria c;
    result_t res = getAccounts( sid, &uid, 1, &c, acc, &len );
    if( res == RES_OK && len == 0 ) return RES_NO_SUCH_USER;
    return res;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申
 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param accounts 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param accountsLen 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申*accounts鐃緒申鐃緒申鐃緒申鐃緒申)
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @see freeAccount
 * 
 */
result_t getAccounts( sessionid_t sid, const userid_t* uids, int uidsLen, criteria_t* cri, const account_t** accounts, int* accountsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( uidsLen <= 0 ){
        *accounts = new account_t[ 0 ];
        *accountsLen = 0;
    syslog_printf( "getAccounts succeed len=0" );
        return RES_OK;
    }
    
    syslog_printf( "begin of getAccounts" );
    result_t ret = RES_ERROR;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    string sql;
    account_t* dst = new account_t[ uidsLen ];
    
    sql += "SELECT u1.uid, u1.name, u1.uname, u1.email, u1.url, u1.user_avatar, u1.user_regdate, u1.user_icq, u1.user_from, u1.user_sig, u1.user_viewemail, u1.actkey, u1.user_aim, u1.user_yim, u1.user_msnm, u1.pass, u1.posts, u1.attachsig, u1.rank, u1.level, u1.theme, u1.timezone_offset, u1.last_login, u1.umode, u1.uorder, u1.notify_method, u1.notify_mode, u1.user_occ, u1.bio, u1.user_intrest, u1.user_mailok, u2.activate, u2.address, u2.division, u2.tel, u2.company_name, u2.country, u2.zipcode, u2.fax, u2.notice_mail, u2.notice_mail_since, u2.private_index_id, u2.private_item_number_limit, u2.private_index_number_limit, u2.private_item_storage_limit ";
    sql += "FROM " + dbprefix + "_users AS u1, " + dbprefix + "_xoonips_users AS u2 ";
    sql += "WHERE u1.uid = u2.uid ";
    if( uidsLen > 0 ){
        syslog_printf( "set uid[%d] value=%d to ...", 0, uids[0] );
        sql += "AND ( u1.uid=" + string( unsignedIntToString( uids[ 0 ] ) );
        for( int i = 1; i < uidsLen; i++ ){
            syslog_printf( "set uid[%d] value=%d to ...", i, uids[i] );
            sql += " OR u1.uid=" + string( unsignedIntToString( uids[ i ] ) );
        }
        sql += " ) ";
    }
    sql += criteria2str( cri );
    syslog_printf( "sql=%s", sql.c_str() );
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        syslog_printf( "SQLAllocHandle" );
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            syslog_printf( "SQLExecDirect" );
            SQLLEN cbUid = 0, cbStorageLimit = 0;
            userid_t uid = 0;
            SQLDOUBLE storage_limit = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &cbUid );
            SQLBindCol( hstmt, 45, SQL_C_DOUBLE, &storage_limit, 0, &cbStorageLimit );
            syslog_printf( "SQLBindCol" );
            *accountsLen=0;
            for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < uidsLen ; i++ ){
                syslog_printf( "SQLFetch" );
                dst[ i ].setUID( uid );
                dst[ i ].setName( getResultCol( hstmt, 2 ).c_str() );
                dst[ i ].setUname( getResultCol( hstmt, 3 ).c_str() );
                dst[ i ].setEmail( getResultCol( hstmt, 4 ).c_str() );
                dst[ i ].setURL( getResultCol( hstmt, 5 ).c_str() );
                dst[ i ].setUserAvatar( getResultCol( hstmt, 6 ).c_str() );
                dst[ i ].setUserRegdate( atoi( getResultCol( hstmt, 7 ).c_str() ) );
                dst[ i ].setUserIcq( getResultCol( hstmt, 8 ).c_str() );
                dst[ i ].setUserFrom( getResultCol( hstmt, 9 ).c_str() );
                dst[ i ].setUserSig( getResultCol( hstmt, 10 ).c_str() );
                dst[ i ].setUserViewemail( atoi( getResultCol( hstmt, 11 ).c_str() ));
                dst[ i ].setActkey( getResultCol( hstmt, 12 ).c_str() );
                dst[ i ].setUserAim( getResultCol( hstmt, 13 ).c_str() );
                dst[ i ].setUserYim( getResultCol( hstmt, 14 ).c_str() );
                dst[ i ].setUserMsnm( getResultCol( hstmt, 15 ).c_str() );
                dst[ i ].setPass( getResultCol( hstmt, 16 ).c_str() );
                dst[ i ].setPosts( atoi( getResultCol( hstmt, 17 ).c_str() ));
                dst[ i ].setAttachsig( atoi( getResultCol( hstmt, 18 ).c_str() ));
                dst[ i ].setRank( atoi( getResultCol( hstmt, 19 ).c_str() ));
                dst[ i ].setLevel( atoi( getResultCol( hstmt, 20 ).c_str() ));
                dst[ i ].setTheme( getResultCol( hstmt, 21 ).c_str() );
                dst[ i ].setTimezoneOffset( atof( getResultCol( hstmt, 22 ).c_str() ) );
                dst[ i ].setLastLogin( atoi( getResultCol( hstmt, 23 ).c_str() ));
                dst[ i ].setUmode( getResultCol( hstmt, 24 ).c_str() );
                dst[ i ].setUorder( atoi( getResultCol( hstmt, 25 ).c_str() ));
                dst[ i ].setNotifyMethod( atoi( getResultCol( hstmt, 26 ).c_str() ));
                dst[ i ].setNotifyMode( atoi( getResultCol( hstmt, 27 ).c_str() ));
                dst[ i ].setUserOcc( getResultCol( hstmt, 28 ).c_str() );
                dst[ i ].setBio( getResultCol( hstmt, 29 ).c_str() );
                dst[ i ].setUserIntrest( getResultCol( hstmt, 30 ).c_str() );
                dst[ i ].setUserMailok( atoi( getResultCol( hstmt, 31 ).c_str() ));
                dst[ i ].setActivate( atoi( getResultCol( hstmt, 32 ).c_str() ));
                dst[ i ].setAddress( getResultCol( hstmt, 33 ).c_str() );
                dst[ i ].setDivision( getResultCol( hstmt, 34 ).c_str() );
                dst[ i ].setTel( getResultCol( hstmt, 35 ).c_str() );
                dst[ i ].setCompanyName( getResultCol( hstmt, 36 ).c_str() );
                dst[ i ].setCountry( getResultCol( hstmt, 37 ).c_str() );
                dst[ i ].setZipcode( getResultCol( hstmt, 38 ).c_str() );
                dst[ i ].setFax( getResultCol( hstmt, 39 ).c_str() );
                dst[ i ].setNoticeMail( atoi( getResultCol( hstmt, 40 ).c_str() ));
                dst[ i ].setNoticeMailSince( atoi( getResultCol( hstmt, 41 ).c_str() ));
                dst[ i ].setPrivateIndexID( atoi( getResultCol( hstmt, 42 ).c_str() ));
                dst[ i ].setItemNumberLimit( atoi( getResultCol( hstmt, 43 ).c_str() ));
                dst[ i ].setIndexNumberLimit( atoi( getResultCol( hstmt, 44 ).c_str() ));
                dst[ i ].setItemStorageLimit( storage_limit );
                ( *accountsLen )++;
            }
            *accounts = dst;
            syslog_printf( "getAccounts succeed" );
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in getAccounts" );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += string( ", sql=" ) + string( sql );
            setLastErrorString( s.c_str( ) );
            syslog_printf( "getAccounts %s", getLastErrorString( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getAccounts" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        syslog_printf( "getAccounts %s", getLastErrorString( ) );
        ret = RES_DB_QUERY_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return RES_OK
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @return RES_DB_NOT_INITIALIZED
 * 
 */
result_t insertAccount( sessionid_t sid, const account_t* account, userid_t* uid )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    string sql;
    string tmp;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    result_t ret = RES_ERROR;
    
    /*
      1. insert user profile into xoops_users
      2. insert platform user profile into xoonips_users
      3. add user to default platform group
      4. create private index
      5. update account set private_index_id=...
     */
    
    //1.xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
    SQLINTEGER user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
    SQLDOUBLE timezone_offset;
    
    SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
    SQLLEN cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;

    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql;
        sql = "INSERT INTO " + dbprefix + "_users (uname, name, email, url, user_avatar, user_regdate, user_icq, user_from, user_sig, user_viewemail, actkey, user_aim, user_yim, user_msnm, pass, posts, attachsig, rank, level, theme, timezone_offset, last_login, umode, uorder, notify_method, notify_mode, user_occ, bio, user_intrest, user_mailok) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
        sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
        if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
            SQLBindParameter(hstmt,  1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
            SQLBindParameter(hstmt,  2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
            SQLBindParameter(hstmt,  3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
            SQLBindParameter(hstmt,  4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
            SQLBindParameter(hstmt,  5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
            SQLBindParameter(hstmt,  6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
            SQLBindParameter(hstmt,  7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
            SQLBindParameter(hstmt,  8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
            SQLBindParameter(hstmt,  9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
            SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
            SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
            SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
            SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
            SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
            SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
            SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
            SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
            SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
            SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
            SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
            SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
            SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
            SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
            SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
            SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
            SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
            SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
            SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
            SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
            SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );

            strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
            strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
            strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
            strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
            strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
            user_regdate = time( NULL );
            strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
            strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
            strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
            user_viewemail = account -> getUserViewemail( );
            strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
            strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
            strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
            strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
            strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
            posts = account -> getPosts( );
            attachsig = account -> getAttachsig( );
            rank = account -> getRank( );
            level = account -> getLevel( );
            strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
            timezone_offset = account -> getTimezoneOffset( );
            last_login = 0;
            strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
            uorder = account -> getUorder( );
            notify_method = account -> getNotifyMethod( );
            notify_mode = account -> getNotifyMode( );
            strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
            strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
            strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
            user_mailok = account -> getUserMailok( );

            if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                SQLLEN count = 0;
                if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                    //鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
                    if( dbtype == DBTYPE_MYSQL ){
                        sql = "SELECT LAST_INSERT_ID()";
                    }else if( dbtype == DBTYPE_SQLITE ){
                        sql = "SELECT LAST_INSERT_ROWID()";
                    }
                    ret = queryGetUnsignedInt( "insertAccount", sql, (unsigned int*)uid );
                }else{
                    string s( "SQLRowCount in insertAccount sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }else{
                string s( "SQLExecute in insertAccount " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            string s( "SQLPrepare in insertAccount " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            setLastErrorString( s.c_str( ) );
            ret = RES_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    
    if( ret == RES_OK ){
        //2.xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
        SQLUINTEGER activate;
        SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
        SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
        SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
        SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
        SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
        SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
        SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
        SQLLEN cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
        SQLLEN cbUid = 0, cbActivate = 0, cbNotice_mail = 0, cbNotice_mail_since = 0, cbItem_number_limit = 0, cbIndex_number_limit = 0, cbItem_storage_limit = 0;
        SQLUINTEGER notice_mail;
        SQLUINTEGER notice_mail_since;
        SQLINTEGER item_number_limit;
        SQLINTEGER index_number_limit;
        SQLDOUBLE item_storage_limit;

        if( ret == RES_OK && ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
            string sql;
            sql = "INSERT INTO " + dbprefix + "_xoonips_users (uid, activate, address, division, tel, company_name, country, zipcode, fax, notice_mail, notice_mail_since, private_item_number_limit, private_index_number_limit, private_item_storage_limit) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )";
            sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
            if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
                SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, uid, 0, &cbUid);
                SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
                SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress); 
                SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision); 
                SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel); 
                SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name); 
                SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry); 
                SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode); 
                SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax); 
                SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
                SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
                SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &item_number_limit, 0, &cbItem_number_limit);
                SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &index_number_limit, 0, &cbIndex_number_limit);
                SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &item_storage_limit, 0, &cbItem_storage_limit);
            
                activate = account -> getActivate() ? 1 : 0;
                strncpy2( (char*)address, account -> getAddress(), XNP_ACCOUNT_ADDRESS_LEN );
                strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
                strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
                strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
                strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
                strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
                strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
                notice_mail = account -> getNoticeMail( );
                notice_mail_since = time( NULL );
                item_number_limit = account -> getItemNumberLimit( );
                index_number_limit = account -> getIndexNumberLimit( );
                item_storage_limit = account -> getItemStorageLimit( );
            
                if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                    SQLLEN count = 0;
                    if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                        ret = RES_OK;
                        if( ret == RES_OK ){
                            //3.add new user to default group(not a group admin)
                            ret = insertMember( sid, group_t::GID_DEFAULT, *uid, false );
                        }else{
                            //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
                            sql = "DELETE FROM " + dbprefix + "_users where uid=";
                            sql += unsignedIntToString( *uid );
                            SQLHANDLE hstmt2 = NULL;
                            if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
                                SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
                                SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
                            }
                            setLastErrorString( "insertMember in insertAccount" );
                            ret = RES_DB_QUERY_ERROR;
                        }
                    }else{
                        string s( "SQLRowCount in insertAccount sql=" );
                        s += string( sql );
                        setLastErrorString( s.c_str( ) );
                        ret = RES_DB_QUERY_ERROR;
                    }
                }else{
                    string s( "SQLExecute in insertAccount " );
                    s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }else{
                //xoops_users鐃緒申insert鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
                sql = "DELETE FROM " + dbprefix + "_users where uid=";
                sql += unsignedIntToString( *uid );
                SQLHANDLE hstmt2 = NULL;
                if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
                    SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() );
                    SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
                }
                string s( "SQLExecDirect in insertAccount sql=" );
                s += string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
            SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
        }else{
            string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
            ret = RES_ERROR;
        }
    }
    
    if ( ret == RES_OK ){
        //4.private index鐃緒申鐃緒申鐃緒申
        
        // private index鐃緒申鐃緒申sort_number鐃緒申鐃緒申
        string sql = "select min(sort_number) from " + 
          dbprefix + "_xoonips_index where parent_index_id=" + unsignedIntToString(item::IID_ROOT) + 
          " and open_level=" + unsignedIntToString(index::OL_PRIVATE);
        unsigned int sortNumber;
        ret = queryGetUnsignedInt( "insertAccount", sql, &sortNumber );
        sortNumber--;
        if ( ret == RES_OK ){
            // private index鐃緒申鐃緒申
            index_t index;
            index.setItemTypeID(item::ITID_INDEX);
            index.setContributorUID(*uid);
            index.setParentIndexID(item::IID_ROOT);
            index.setOwnerUID(*uid);
            index.setOpenLevel(index::OL_PRIVATE);
            index.setSortNumber(sortNumber);
            index.setTitle(account->getUname());
            indexid_t privateXID;
            ret = insertIndexInternal( sid, &index, &privateXID );
            if ( ret == RES_OK ){
                // xnpaccuont_users鐃緒申private_index_id鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
                sql = "UPDATE " + dbprefix + "_xoonips_users SET private_index_id=" 
                  + unsignedIntToString(privateXID) + " WHERE uid=" + unsignedIntToString(*uid);
                ret = querySimple( "insertAccount", sql );
            }
        }
    }
    
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * account鐃緒申uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param account 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @return RES_NO_SUCH_USER
 * @return RES_ERROR
 * 
 */
result_t updateAccount( sessionid_t sid, const account_t* account )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( account == NULL ) return RES_ERROR;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !uidExists( account -> getUID( ) ) ) return RES_NO_SUCH_USER;

    SQLRETURN sqlcode;
    result_t ret = RES_ERROR;
    SQLHANDLE hstmt = NULL;
    
    //xoops鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    SQLCHAR uname[ACCOUNT_UNAME_LEN+1], name[ACCOUNT_NAME_LEN+1], email[ACCOUNT_EMAIL_LEN+1], url[ACCOUNT_URL_LEN+1], user_avatar[ACCOUNT_USER_AVATAR_LEN+1], user_icq[ACCOUNT_USER_ICQ_LEN+1], user_from[ACCOUNT_USER_FROM_LEN+1], user_sig[ACCOUNT_USER_SIG_LEN+1], actkey[ACCOUNT_ACTKEY_LEN+1], user_aim[ACCOUNT_USER_AIM_LEN+1], user_yim[ACCOUNT_USER_YIM_LEN+1], user_msnm[ACCOUNT_USER_MSNM_LEN+1], pass[ACCOUNT_PASS_LEN+1], theme[ACCOUNT_THEME_LEN+1], umode[ACCOUNT_UMODE_LEN+1], user_occ[ACCOUNT_USER_OCC_LEN+1], bio[ACCOUNT_BIO_LEN+1], user_intrest[ACCOUNT_USER_INTREST_LEN+1];
    SQLINTEGER uid, user_regdate, user_viewemail, posts, attachsig, rank, level, last_login, uorder, notify_method, notify_mode, user_mailok;
    SQLDOUBLE timezone_offset;
    
    SQLLEN cbUname = SQL_NTS, cbName = SQL_NTS, cbEmail = SQL_NTS, cbUrl = SQL_NTS, cbUser_avatar = SQL_NTS, cbUser_icq = SQL_NTS, cbUser_from = SQL_NTS, cbUser_sig = SQL_NTS, cbActkey = SQL_NTS, cbUser_aim = SQL_NTS, cbUser_yim = SQL_NTS, cbUser_msnm = SQL_NTS, cbPass = SQL_NTS, cbTheme = SQL_NTS, cbUmode = SQL_NTS, cbUser_occ = SQL_NTS, cbBio = SQL_NTS, cbUser_intrest = SQL_NTS;
    SQLLEN cbUid = 0, cbUser_regdate = 0, cbUser_viewemail = 0, cbPosts = 0, cbAttachsig = 0, cbRank = 0, cbLevel = 0, cbLast_login = 0, cbUorder = 0, cbNotify_method = 0, cbNotify_mode = 0, cbUser_mailok = 0, cbTimezone_offset = 0;

    SQLUINTEGER activate;
    SQLCHAR address[XNP_ACCOUNT_ADDRESS_LEN+1];
    SQLCHAR division[XNP_ACCOUNT_DIVISION_LEN+1];
    SQLCHAR tel[XNP_ACCOUNT_TEL_LEN+1];
    SQLCHAR company_name[XNP_ACCOUNT_COMPANY_NAME_LEN+1];
    SQLCHAR country[XNP_ACCOUNT_COUNTRY_LEN+1];
    SQLCHAR zipcode[XNP_ACCOUNT_ZIPCODE_LEN+1];
    SQLCHAR fax[XNP_ACCOUNT_FAX_LEN+1];
    SQLLEN cbActivate = 0, cbAddress = SQL_NTS, cbDivision = SQL_NTS, cbTel = SQL_NTS, cbCompany_name = SQL_NTS, cbCountry = SQL_NTS, cbZipcode = SQL_NTS, cbFax = SQL_NTS;
    SQLUINTEGER notice_mail, notice_mail_since;
    SQLLEN cbNotice_mail = 0, cbNotice_mail_since = 0;

    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql;

        sql = "UPDATE " + dbprefix + "_users SET ";
        sql += "uname=?";
        sql += ", name=?";
        sql += ", email=?";
        sql += ", url=?";
        sql += ", user_avatar=?";
        sql += ", user_regdate=?";
        sql += ", user_icq=?";
        sql += ", user_from=?";
        sql += ", user_sig=?";
        sql += ", user_viewemail=?";
        sql += ", actkey=?";
        sql += ", user_aim=?";
        sql += ", user_yim=?";
        sql += ", user_msnm=?";
        sql += ", pass=?";
        sql += ", posts=?";
        sql += ", attachsig=?";
        sql += ", rank=?";
        sql += ", level=?";
        sql += ", theme=?";
        sql += ", timezone_offset=?";
        sql += ", last_login=?";
        sql += ", umode=?";
        sql += ", uorder=?";
        sql += ", notify_method=?";
        sql += ", notify_mode=?";
        sql += ", user_occ=?";
        sql += ", bio=?";
        sql += ", user_intrest=?";
        sql += ", user_mailok=? ";
        sql += " WHERE uid = ?";

        sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
        if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
            SQLBindParameter(hstmt,  1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UNAME_LEN, 0, uname, 0, &cbUname );
            SQLBindParameter(hstmt,  2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_NAME_LEN, 0, name, 0, &cbName );
            SQLBindParameter(hstmt,  3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_EMAIL_LEN, 0, email, 0, &cbEmail );
            SQLBindParameter(hstmt,  4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_URL_LEN, 0, url, 0, &cbUrl );
            SQLBindParameter(hstmt,  5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AVATAR_LEN, 0, user_avatar, 0, &cbUser_avatar );
            SQLBindParameter(hstmt,  6, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_regdate, 0, &cbUser_regdate );
            SQLBindParameter(hstmt,  7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_ICQ_LEN, 0, user_icq, 0, &cbUser_icq );
            SQLBindParameter(hstmt,  8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_FROM_LEN, 0, user_from, 0, &cbUser_from );
            SQLBindParameter(hstmt,  9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_SIG_LEN, 0, user_sig, 0, &cbUser_sig );
            SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_viewemail, 0, &cbUser_viewemail );
            SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_ACTKEY_LEN, 0, actkey, 0, &cbActkey );
            SQLBindParameter(hstmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_AIM_LEN, 0, user_aim, 0, &cbUser_aim );
            SQLBindParameter(hstmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_YIM_LEN, 0, user_yim, 0, &cbUser_yim );
            SQLBindParameter(hstmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_MSNM_LEN, 0, user_msnm, 0, &cbUser_msnm );
            SQLBindParameter(hstmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_PASS_LEN, 0, pass, 0, &cbPass );
            SQLBindParameter(hstmt, 16, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &posts, 0, &cbPosts );
            SQLBindParameter(hstmt, 17, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &attachsig, 0, &cbAttachsig );
            SQLBindParameter(hstmt, 18, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &rank, 0, &cbRank );
            SQLBindParameter(hstmt, 19, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &level, 0, &cbLevel );
            SQLBindParameter(hstmt, 20, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_THEME_LEN, 0, theme, 0, &cbTheme );
            SQLBindParameter(hstmt, 21, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &timezone_offset, 0, &cbTimezone_offset );
            SQLBindParameter(hstmt, 22, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &last_login, 0, &cbLast_login );
            SQLBindParameter(hstmt, 23, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_UMODE_LEN, 0, umode, 0, &cbUmode );
            SQLBindParameter(hstmt, 24, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uorder, 0, &cbUorder );
            SQLBindParameter(hstmt, 25, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_method, 0, &cbNotify_method );
            SQLBindParameter(hstmt, 26, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &notify_mode, 0, &cbNotify_mode );
            SQLBindParameter(hstmt, 27, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_OCC_LEN, 0, user_occ, 0, &cbUser_occ );
            SQLBindParameter(hstmt, 28, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_BIO_LEN, 0, bio, 0, &cbBio );
            SQLBindParameter(hstmt, 29, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, ACCOUNT_USER_INTREST_LEN, 0, user_intrest, 0, &cbUser_intrest );
            SQLBindParameter(hstmt, 30, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &user_mailok, 0, &cbUser_mailok );
            SQLBindParameter(hstmt, 31, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
            
            strncpy2( (char*)uname, account -> getUname( ), ACCOUNT_UNAME_LEN );
            strncpy2( (char*)name, account -> getName( ), ACCOUNT_NAME_LEN );
            strncpy2( (char*)email, account -> getEmail( ), ACCOUNT_EMAIL_LEN );
            strncpy2( (char*)url, account -> getURL( ), ACCOUNT_URL_LEN );
            strncpy2( (char*)user_avatar, account -> getUserAvatar( ), ACCOUNT_USER_AVATAR_LEN );
            user_regdate = time( NULL );
            strncpy2( (char*)user_icq, account -> getUserIcq( ), ACCOUNT_USER_ICQ_LEN );
            strncpy2( (char*)user_from, account -> getUserFrom( ), ACCOUNT_USER_FROM_LEN );
            strncpy2( (char*)user_sig, account -> getUserSig( ), ACCOUNT_USER_SIG_LEN );
            user_viewemail = account -> getUserViewemail( );
            strncpy2( (char*)actkey, account -> getActkey( ), ACCOUNT_ACTKEY_LEN );
            strncpy2( (char*)user_aim, account -> getUserAim( ), ACCOUNT_USER_AIM_LEN );
            strncpy2( (char*)user_yim, account -> getUserYim( ), ACCOUNT_USER_YIM_LEN );
            strncpy2( (char*)user_msnm, account -> getUserMsnm( ), ACCOUNT_USER_MSNM_LEN );
            strncpy2( (char*)pass, account -> getPass( ), ACCOUNT_PASS_LEN );
            posts = account -> getPosts( );
            attachsig = account -> getAttachsig( );
            rank = account -> getRank( );
            level = account -> getLevel( );
            strncpy2( (char*)theme, account -> getTheme( ), ACCOUNT_THEME_LEN );
            timezone_offset = account -> getTimezoneOffset( );
            last_login = 0;
            strncpy2( (char*)umode, account -> getUmode( ), ACCOUNT_UMODE_LEN );
            uorder = account -> getUorder( );
            notify_method = account -> getNotifyMethod( );
            notify_mode = account -> getNotifyMode( );
            strncpy2( (char*)user_occ, account -> getUserOcc( ), ACCOUNT_USER_OCC_LEN );
            strncpy2( (char*)bio, account -> getBio( ), ACCOUNT_BIO_LEN );
            strncpy2( (char*)user_intrest, account -> getUserIntrest( ), ACCOUNT_USER_INTREST_LEN );
            user_mailok = account -> getUserMailok( );
            uid = account -> getUID( );
            
            if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                SQLLEN count = 0;
                if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                    ret = RES_OK;
                }else{
                    string s( "SQLRowCount in updateAccount sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }else{
                string s( "SQLExecute in updateAccount 1 " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            setLastErrorString( "SQLPrepare in updateAccount sql=" );
            ret = RES_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
        hstmt = NULL;
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    
    if( ret != RES_OK ){
        return ret;
    }
    
    //xoonips鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql;

        sql = "UPDATE " + dbprefix + "_xoonips_users SET ";
        sql += "activate=?, ";
        sql += "address=?, ";
        sql += "division=?, ";
        sql += "tel=?, ";
        sql += "company_name=?, ";
        sql += "country=?, ";
        sql += "zipcode=?, ";
        sql += "fax=?, ";
        sql += "notice_mail=?, ";
        sql += "notice_mail_since=? ,";
        sql += "private_item_number_limit=" + unsignedIntToString( account -> getItemNumberLimit( ) ) + " ,";
        sql += "private_index_number_limit=" + unsignedIntToString( account -> getIndexNumberLimit( ) ) + " ,";
        sql += "private_item_storage_limit=" + doubleToString( account -> getItemStorageLimit( ) ) + " ";
        sql += "WHERE uid=?"; 
    
        sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
        if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
            SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &activate, 0, &cbActivate);
            SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ADDRESS_LEN, 0, address, 0, &cbAddress); 
            SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_DIVISION_LEN, 0, division, 0, &cbDivision); 
            SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_TEL_LEN, 0, tel, 0, &cbTel); 
            SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COMPANY_NAME_LEN, 0, company_name, 0, &cbCompany_name); 
            SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_COUNTRY_LEN, 0, country, 0, &cbCountry); 
            SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_ZIPCODE_LEN, 0, zipcode, 0, &cbZipcode); 
            SQLBindParameter(hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_ACCOUNT_FAX_LEN, 0, fax, 0, &cbFax); 
            SQLBindParameter(hstmt, 9, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail, 0, &cbNotice_mail);
            SQLBindParameter(hstmt, 10, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &notice_mail_since, 0, &cbNotice_mail_since);
            SQLBindParameter(hstmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &uid, 0, &cbUid );
            
            activate = account -> getActivate() ? 1 : 0;
            strncpy2( (char*)address, account -> getAddress( ) , XNP_ACCOUNT_ADDRESS_LEN );
            strncpy2( (char*)division, account -> getDivision(), XNP_ACCOUNT_DIVISION_LEN );
            strncpy2( (char*)tel, account -> getTel(), XNP_ACCOUNT_TEL_LEN );
            strncpy2( (char*)company_name, account -> getCompanyName(), XNP_ACCOUNT_COMPANY_NAME_LEN );
            strncpy2( (char*)country, account -> getCountry(), XNP_ACCOUNT_COUNTRY_LEN );
            strncpy2( (char*)zipcode, account -> getZipcode(), XNP_ACCOUNT_ZIPCODE_LEN );
            strncpy2( (char*)fax, account -> getFax(), XNP_ACCOUNT_FAX_LEN );
            notice_mail = account -> getNoticeMail( );
            notice_mail_since = account -> getNoticeMailSince( );
            uid = account -> getUID( );
            
            if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                SQLLEN count = 0;
                if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                    ret = RES_OK;
                }else{
                    string s( "SQLRowCount in updateAccount sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }else{
                string s( "SQLExecute in updateAccount 2 " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            setLastErrorString( "SQLPrepare in updateAccount sql=" );
            ret = RES_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateAccount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * criteria_t鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申*uidsLen鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @see freeUID
 */
result_t dumpUids( sessionid_t sid, criteria_t* cri, userid_t** uids, int* uidsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    result_t ret = RES_ERROR;
    userid_t* dst = 0;
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            

    sql = "SELECT uid FROM " + dbprefix + "_xoonips_users ";
    sql += criteria2str( cri );
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        *uidsLen = count;
        dst = new userid_t[ *uidsLen ];
        *uids = dst;
    }else{
        return RES_ERROR;
    }
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            userid_t uid = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );

            for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
                dst[ i ] = uid;
            }
            
            syslog_printf( "dumpUids succeed" );
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in dumpUids " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            syslog_printf( "dumpUids %s", getLastErrorString( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in dumpUids" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        syslog_printf( "dumpUids %s", getLastErrorString( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申0鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 */
int getGroupCount( sessionid_t sid )
{
    if( hdbc == NULL ) return 0;
    if( !isValidSessionID( sid ) ) return 0;
    
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    string sql;
    int ret = 0;
    
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups";
    sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLUINTEGER count = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                ret = count;
            }else {
                string s( "SQLFetch in getGroupCount sql=" );
                s += string( sql );
                setLastErrorString( s.c_str( ) );
                ret = 0;
            }
        }else{
            setLastErrorString( "SQLExecDirect in getGroupCount" );
            ret = 0;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getGroupCount" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = 0;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(default鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申).
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_USER
 * @return RES_DB_QUERY_ERROR
 * @return RES_OK
 * @see freeGID
 */
result_t getGroupsByUid( sessionid_t sid, userid_t uid, criteria_t* cri, groupid_t** gids, int* gidsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    
    result_t ret = RES_ERROR;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    SQLLEN count = 0;
    groupid_t* dst = 0;
    
    sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups_users_link";
    sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
    sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
    sql += criteria2str( cri );
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        *gidsLen = count;
        dst = new groupid_t[ *gidsLen ];
        *gids = dst;
    }else{
        return RES_ERROR;
    }
    
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            if( count > 0 ){
                SQLHANDLE hstmt2 = NULL;    
                if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
                    sql = "SELECT gid, uid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link";
                    sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
                    sql += " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
                    sql += criteria2str( cri );
                    if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
                        SQLLEN len = 0;
                        groupid_t gid = 0;
                        SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
                        for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
                            dst[ i ] = gid;
                        }
                        ret = RES_OK;
                    }else{
                        string s( "SQLExecDirect in getGroupsByUid " );
                        s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                        s += string( ", sql=" ) + string( sql );
                        setLastErrorString( s.c_str( ) );
                        ret = RES_DB_QUERY_ERROR;
                    }
                }else{
                    string s( "SQLAllocHandle in getGroupsByUid " );
                    s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_ERROR;
                }
            }else{
                ret = RES_OK;
            }
        }else{
            string s( "SQLExecDirect in getGroupsByUid " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += string( ", sql=" ) + string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
    }else{
        string s( "SQLAllocHandle in getGroupsByUid " );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申(鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申)鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申false鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申UID
 * @return true 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return false 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @see 
 */
bool isGroupAdmin( sessionid_t sid, groupid_t gid, userid_t uid )
{
    if( hdbc == NULL ) return false;
    if( !isValidSessionID( sid ) ) return false;
    if( !uidExists( uid ) ) return false;
    if( !gidExists( gid ) ) return false;
    
    bool ret = false;
    string sql;
    SQLLEN count = 0;
    
    sql = "SELECT * FROM " + dbprefix + "_xoonips_groups_users_link ";
    sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
    sql += " AND uid=" + string( unsignedIntToString( uid ) );
    sql += " AND is_admin=1";
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        if( count > 0 ){
            ret = true;
        }else{
            ret = false;
        }
    }else{
        ret = false;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param gids 鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param gidsLen gids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @return RES_OK
 * 
 */
result_t dumpGids( sessionid_t sid, criteria_t* cri, groupid_t** gids, int* gidsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    result_t ret = RES_ERROR;
    groupid_t* dst = 0;
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            
    sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups ";
    sql += " WHERE gid != " + unsignedIntToString( group::GID_DEFAULT );
    sql += criteria2str( cri );
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        *gidsLen = count;
        dst = new groupid_t[ *gidsLen ];
        *gids = dst;
    }else{
        return RES_ERROR;
    }
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            groupid_t gid = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &gid, 0, &len );
            for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *gidsLen ; i++ ){
                dst[ i ] = gid;
            }
            
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in dumpGids " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @return RES_ERROR 
 * 
 */
result_t dumpGroupAdmins( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    result_t ret = RES_ERROR;
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            
    sql = "SELECT uid FROM " + dbprefix + "_xoonips_groups_users_link ";
    sql += " WHERE is_admin=1 and gid=" + unsignedIntToString( gid );
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        *uidsLen = count;
        *uids = new groupid_t[ *uidsLen ];
    }else{
        return RES_ERROR;
    }
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            userid_t uid;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &uid, 0, &len );
            for( int i = 0; ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS && i < *uidsLen ; i++ ){
                (*uids)[ i ] = uid;
            }
            ret = RES_OK;
        }else{
            string s( "SQLExecDirect in dumpGroupAdmins " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += "sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_USER
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * @return RES_OK
 * @return RES_ERROR
 * 
 */
result_t deleteMember( sessionid_t sid, groupid_t gid, userid_t uid )
{
    if( gid == group_t::GID_DEFAULT ) return RES_ERROR;
    return deleteMemberNoLimit( sid, gid, uid );
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申deleteMember鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_USER
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * @return RES_OK
 * @return RES_ERROR
 * 
 */
static result_t deleteMemberNoLimit( sessionid_t sid, groupid_t gid, userid_t uid )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    
    result_t ret = RES_ERROR;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    
    sql = "DELETE FROM " + dbprefix + "_xoonips_groups_users_link ";
    sql += "WHERE gid=" + string( unsignedIntToString( gid ) );
    sql += " AND uid=" + string( unsignedIntToString( uid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret = RES_OK;
            }else{
                string s( "SQLRowCount in deleteMember" );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_NO_SUCH_USER;
            }
        }else{
            string s( "SQLExecDirect in deleteMember" );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteMember" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param uid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param admin 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申true
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_USER
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * 
 */
result_t insertMember( sessionid_t sid, groupid_t gid, userid_t uid, bool admin )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !uidExists( uid ) ) return RES_NO_SUCH_USER; //uid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    
    result_t ret = RES_ERROR;
    string sql;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    
    //鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        sql = "INSERT INTO " + dbprefix + "_xoonips_groups_users_link ( gid, uid, is_admin ) VALUES (";
        sql += string( unsignedIntToString( gid ) ) + ", ";
        sql += string( unsignedIntToString( uid ) ) + ", ";
        sql += string( admin ? "1" : "0" ) + ") ";
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret = RES_OK;
            }else{
                string s( "SQLRowCount in insertMember " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            string s( "SQLExecDirect in insertMember " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += string( ", sql=" ) + string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertMember" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
 * @param cri 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uids 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申UID鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param uidsLen uids鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * @return RES_ERROR 
 * 
 */
result_t getMembers( sessionid_t sid, groupid_t gid, criteria_t* cri, userid_t** uids, int* uidsLen )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !gidExists( gid ) ) return RES_NO_SUCH_GROUP; //gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
    
    result_t ret = RES_ERROR;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;    
    userid_t* dst = 0;
    
    //how many members ?
    sql = "SELECT COUNT(*) FROM " + dbprefix + "_xoonips_groups_users_link ";
    sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLUINTEGER count = 0;
            SQLLEN len = 0;
            SQLBindCol( hstmt, 1, SQL_C_ULONG, &count, 0, &len );
            if( ( sqlcode = SQLFetch( hstmt ) ) == SQL_SUCCESS ){
                dst = new userid_t[ count ];
                *uids = dst;
                *uidsLen = count;
                if( count > 0 ){
                    //retrieve member's IDs
                    SQLHANDLE hstmt2 = NULL;    
                   if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt2 ) ) == SQL_SUCCESS ) {
                        sql = "SELECT uid, gid, is_admin FROM " + dbprefix + "_xoonips_groups_users_link ";
                        sql += " WHERE gid=" + string( unsignedIntToString( gid ) );
                        sql += " " + string( criteria2str( cri ) );
                        if( ( sqlcode = SQLExecDirect( hstmt2, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
                            SQLUINTEGER uid = 0;
                            SQLLEN len = 0;
                            SQLBindCol( hstmt2, 1, SQL_C_ULONG, &uid, 0, &len );
                            for( SQLUINTEGER i = 0; ( sqlcode = SQLFetch( hstmt2 ) ) == SQL_SUCCESS && i < count ; i++ ){
                                dst[ i ] = uid;
                            }
                            ret = RES_OK;
                        }else{
                            setLastErrorString( "SQLExecDirect in getMembers" );
                            ret = RES_DB_QUERY_ERROR;
                        }
                        SQLFreeHandle( SQL_HANDLE_STMT, hstmt2 );
                    }else{
                        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
                        ret = RES_ERROR;
                    }
                }else{
                    ret = RES_OK;
                }
            }else{
                string s( "SQLFetch in getMembers sql=" );
                s += string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            setLastErrorString( "SQLExecDirect in getMembers" );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in getMembers" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}

/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申.
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申鐃緒申鐃緒申
 * @return RES_OK
 * @return RES_DB_QUERY_ERROR
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_NOT_INITIALIZED
 * 
 */
result_t deleteGroup( sessionid_t sid, groupid_t gid )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    result_t ret = RES_ERROR;
    string sql;
    SQLRETURN sqlcode;
    SQLHANDLE hstmt = NULL;
    
    sql = "DELETE FROM " + dbprefix + "_xoonips_groups ";
    sql += "WHERE gid = " + string( unsignedIntToString( gid ) );
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), sql.length() ) ) == SQL_SUCCESS ){
            SQLLEN count = 0;
            if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                ret = RES_OK;
            }else{
                string s( "SQLRowCount in deleteGroup" );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                s += string( ", sql=" ) + string( sql );
                setLastErrorString( s.c_str( ) );
                ret = RES_NO_SUCH_USER;
            }
        }else{
            string s( "SQLExecDirect in deleteGroup" );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            s += ", sql=";
            s += string( sql );
            setLastErrorString( s.c_str( ) );
            ret = RES_DB_QUERY_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in deleteGroup" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    return ret;
}


/**
 * 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申. 
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID鐃緒申gid鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * 
 * @param sid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @param group 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申
 * @param gid 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申ID
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * @return RES_GROUPNAME_ALREADY_EXISTS
 */
result_t insertGroup( sessionid_t sid, const group_t* group, groupid_t* gid )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    
    result_t ret = RES_ERROR;
    string sql;
    SQLCHAR gname[XNP_GROUP_GNAME_LEN+1], gdesc[XNP_GROUP_GDESC_LEN+1];
    SQLINTEGER item_number_limit;
    SQLINTEGER index_number_limit;
    SQLDOUBLE item_storage_limit;
    SQLLEN cbGname = SQL_NTS, cbGdesc = SQL_NTS, cbItem_number_limit = 0, cbIndex_number_limit = 0, cbItem_storage_limit = 0;
    SQLHANDLE hstmt = NULL;
    SQLRETURN sqlcode;
    
    // examine whether there is already a group name
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql = "SELECT gid FROM " + dbprefix + "_xoonips_groups WHERE gname=? AND gid!=" + unsignedIntToString(group -> getGID() ) + " AND gid != " + unsignedIntToString( group::GID_DEFAULT );
        sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
        if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
            SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_GROUP_GNAME_LEN, 0, gname, 0, &cbGname );
            strncpy2( (char*)gname, group -> getGname(), XNP_GROUP_GNAME_LEN );
            if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                SQLLEN count = 0;
                if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS ){
                    if( count > 0 ){
                        // already exists
                        ret = RES_GROUPNAME_ALREADY_EXISTS;
                        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
                        return ret;
                    }
                }else{
                    string s( "SQLRowCount in insertGroup sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                    return ret;
                }
            }else{
                string s( "SQLExecute in insertGroup " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            string s( "SQLPrepare in insertGroup " );
            s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
            setLastErrorString( s.c_str( ) );
            ret = RES_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }
    
    if( 