xoonips/AL/commonal.cc

/*
 * 
 * $Revision: 1.73 $
 * $Log: commonal.cc,v $
 * 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 繧奪B繝ｻ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縺ｸ逋ｻ骭ｲ繧定｡後↑縺?/span>
 * getItems: getItemPermission繧剃ｽｿ縺｣縺溯ｪｭ縺ｿ霎ｼ縺ｿ讓ｩ髯舌メ繧ｧ繝?け.
 *
 * Revision 1.43  2005/01/19 01:42:15  aga
 * 繝ｻx_xnpaccount_index縺ｮgid,uid縺?縺ｫ縺ｪ繧峨↑縺?ｈ縺?ｿｮ豁｣.
 *
 * Revision 1.42  2005/01/19 00:51:29  aga
 * 繝ｻinsertIndex縺ｧx_xnpaccount_index.index_id縺後♀縺九＠縺??繧剃ｿｮ豁｣.
 *
 * Revision 1.41  2005/01/19 00:06:51  aga
 * 繝ｻupdateIndex縺ｧ縲∝酔縺伜錐蜑阪?蜈?ｼ溘′縺ゅｋ縺句錐蜑阪′遨ｺ縺ｧ縺ゅｋ縺ｪ繧峨お繝ｩ繝ｼ縺ｫ縺励◆.
 * 繝ｻcreateSession縺ｧ縲「id縺訓latform繝ｦ繝ｼ繧ｶ縺ｧ縺ｪ縺?°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_xnpaccount_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繧湛NP縺ｫ螟画鋤.
 *
 * Revision 1.35  2005/01/06 07:20:17  youi
 * WIN32螳夂ｾｩ譎ゅ?繧､繝ｳ繧ｯ繝ｫ繝ｼ繝峨?霑ｽ蜉?.
 * MySQL API縺ｫ髢｢縺吶ｋ繝倥ャ繝?繝輔ぃ繧､繝ｫ繧貞炎髯､.
 * deleteAccount: 謇?螻槭☆繧輝latform繧ｰ繝ｫ繝ｼ繝励°繧峨?蜑企勁繧貞?阡ｵ縺励◆.
 * insertAccount: 繝ｦ繝ｼ繧ｶ逋ｻ骭ｲ縺ｨ蜷梧凾縺ｫ繝?ヵ繧ｩ繝ｫ繝?latform繧ｰ繝ｫ繝ｼ繝励∈逋ｻ骭ｲ縺吶ｋ.
 * deleteMember: 繝?ヵ繧ｩ繝ｫ繝?latform繧ｰ繝ｫ繝ｼ繝励°繧峨?蜑企勁繧堤ｦ∵ｭ｢縺吶ｋ.
 * 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繧貞ｮ夂ｾｩ縺励◆縺ｨ縺搾ｼ勲YSQL縺ｮDLL繧貞虚逧?Μ繝ｳ繧ｯ縺吶ｋ繝励Ο繝医ち繧､繝怜ｮ｣險?縺?/span>
 * 譛牙柑縺ｫ縺ｪ繧九ｈ縺?↓菫ｮ豁｣縺励◆.
 *
 * Revision 1.29  2004/12/18 01:12:29  youi
 * freeResult縺ｮ髢｢謨ｰ蜷阪ｒfree<繝??繧ｿ蝙?gt;縺ｫ螟画峩縺励◆.
 *
 * Revision 1.28  2004/12/14 12:02:08  youi
 * __WIN__繧貞ｮ夂ｾｩ縺励◆縺ｨ縺阪?windows縺ｮdll菴懈?縺ｫ蠢?ｦ√↑蜃ｦ逅?ｒ陦後↑縺?
 * USE_SYSLOG繧貞ｮ夂ｾｩ縺励◆縺ｨ縺阪?syslogd縺ｸ繝｡繝?そ繝ｼ繧ｸ繧貞?蜉帙☆繧?
 * getAccounts: uidsLen縺?縺ｮ縺ｨ縺阪?蜃ｦ逅?ｒ霑ｽ蜉?縺励◆.
 *
 * Revision 1.27  2004/12/06 11:34:47  aga
 * 繝ｻuninitializeDB()繧定ｿｽ蜉?.
 *
 * Revision 1.26  2004/12/06 10:17:36  youi
 * mysql_use_result縺ｮ蜿門ｾ礼ｵ先棡繧呈ｮ九＆縺壼叙繧雁?縺吶◆繧?ｼ?/span>
 * while( row = mysql_fetch_row(result) );繧呈諺蜈･??/span>
 *
 * Revision 1.25  2004/12/06 07:24:33  youi
 * insertAccount, insertGroup:
 *     譁ｰ隕剰ｿｽ蜉?縺励◆諠??ｱ縺ｫ蟇ｾ蠢懊☆繧九Θ繝ｼ繧ｶID?後げ繝ｫ繝ｼ繝悠D繧堤ｬｬ荳牙ｼ墓焚縺ｫ譖ｸ縺崎ｾｼ繧?.
 *
 * Revision 1.24  2004/12/06 01:45:50  aga
 * 繝ｻ繧ｳ繝｡繝ｳ繝医▽縺?
 * 繝ｻ髢区叛蠢倥ｌ菫ｮ豁｣.
 *
 * Revision 1.23  2004/12/04 09:21:10  aga
 * 繝ｻxnp_config 竊 xnpaccount_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繧貞ｮ夂ｾｩ.
 * 繝??繧ｿ繝吶?繧ｹ蛻晄悄蜑阪?蜻ｼ蜃ｺ縺ｫ蟇ｾ縺暦ｼ軍ES_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 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 <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 SQLHANDLE henv = NULL;
static SQLHANDLE hdbc = NULL;
static SQLHANDLE hstmt = 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 );

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

/**
 * 
 * public_item_target_user縺ｮ險ｭ螳壼?､縺?#39;all'縺ｪ繧液rue繧偵°縺医☆
 * 險ｭ螳壼?､縺ｮ蜿門ｾ励↓螟ｱ謨励＠縺溷?ｴ蜷茨ｼ?#39;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;
}


/**
 * 
 * 繧､繝ｳ繝?ャ繧ｯ繧ｹ逋ｻ骭ｲ?後い繧､繝?Β譖ｴ譁ｰ繧定｡後↑縺｣縺溘→縺阪?謇ｿ隱咲憾諷九?蛻晄悄蛟､繧抵ｼ?/span>
 * 繧ｷ繧ｹ繝?Β險ｭ螳壹↓縺励◆縺後▲縺ｦ霑斐＠縺ｾ縺呻ｼ?/span>
 * 
 */
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;
}

/**
 * 
 * 繧ｻ繝?す繝ｧ繝ｳ縺ｫ蟇ｾ蠢應ｻ倥¢繧峨ｌ縺溘Θ繝ｼ繧ｶ縺鯉ｼ訓latform繝ｦ繝ｼ繧ｶ縺ｨ縺励※Activate縺?/span>
 * 繧後※縺?ｋ縺九ｒ霑斐☆
 *
 * @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;
}

/**
 * 
 * 繧ｻ繝?す繝ｧ繝ｳ縺ｫ蟇ｾ蠢應ｻ倥¢繧峨ｌ縺溘Θ繝ｼ繧ｶ縺鯉ｼ後Δ繝?Ξ繝ｼ繧ｿ縺ｧ縺ゅｋ縺具ｼ?/span>
 * 
 * 
 * @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;
}


/** SQL繧貞ｮ溯｡後☆繧九?らｵ先棡縺ｯ謐ｨ縺ｦ繧九??/span>
  * @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繧貞ｮ溯｡後＠縲?陦檎岼縺ｮ譛?蛻昴?謨ｴ謨ｰ蛟､(NULL縺ｪ繧?縺ｨ縺ｿ縺ｪ縺?縺ｮ縺ｿ蜿励¢蜿悶ｋ縲?/span>
  * @param sql sql
  * @param u   謨ｴ謨ｰ蛟､繧貞女縺大叙繧句､画焚縲?/span>
  * @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;
}

/**
 * 
 * 譁?ｭ怜?繧ｳ繝斐???/span>
 * 謖?ｮ壽枚蟄玲焚繧偵さ繝斐?縺暦ｼ後ヰ繝?ヵ繧｡縺ｮ譛?蠕後ｒNULL邨らｫｯ縺吶ｋ??/span>
 * ( 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縺ｮ螳溯｡檎ｵ先棡縺九ｉ繧ｨ繝ｩ繝ｼ譁?ｭ怜?繧堤函謌舌☆繧?/span>
 * 
 * @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 )
{
    string s;
    SQLRETURN  sqlcode;
    SQLCHAR    BinaryPtr[5000];
    SQLLEN     BinaryLenOrInd;
    SQLINTEGER NumBytes;
    
    syslog_printf( "getResultCol" );
    while ( ( sqlcode = SQLGetData(hstmt, col, SQL_C_CHAR, 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;
}


/** 
 * 
 * 繧ｯ繧ｩ繝ｼ繝医↑縺ｩ繧箪險伜捷縺ｧ繧ｨ繧ｹ繧ｱ繝ｼ繝励☆繧?/span>
 * 
 * @param str addslashes縺吶∋縺肴枚蟄怜?縲?ULL謖?ｮ壻ｸ榊庄縲?/span>
 * @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 縺ｮ險ｭ螳壹ｒ隱ｿ縺ｹ繧?/span>
  * @param module 繝｢繧ｸ繝･繝ｼ繝ｫ縺ｮdirname
  * @param key    險ｭ螳壹?key
  * @param value  險ｭ螳壹ｒ霑斐☆螟画焚縲?/span>
  * @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 );
        if( ( sqlcode = SQLExecDirect( hstmt, (SQLCHAR*)sql.c_str(), strlen( sql.c_str() ) ) ) == SQL_SUCCESS ){
            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;
}

/** 繧ｲ繧ｹ繝医Θ繝ｼ繧ｶ縺傾ooNiPs縺ｮPublic縺ｪ繧｢繧､繝?Β繧定ｦ九ｋ縺薙→縺後〒縺阪ｋ縺九←縺?°繧定ｿ斐☆縲?/span>
  */
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繧貞ｾ励ｋ縲?/span>
  * @param sid session id 
  * @param uid uid繧貞女縺大叙繧句､画焚
  * @return RES_OK  
  *   sid縺ｯ譛牙柑縺ｪsessionid縺ｧ縺ゅｋ縲ゅ％縺ｮ蝣ｴ蜷?uid縺ｫ縺ｯ譛牙柑縺ｪuid縺悟?繧九??/span>
  *   縺ゅｋ縺??縲∝?髢九い繧､繝?Β繧帝撼XooNiPs繝ｦ繝ｼ繧ｶ縺ｫ蜈ｬ髢 縺九▽sid縺茎ession::SID_GUEST(=0)縺ｧ縺ゅｋ縲ゅ％縺ｮ蝣ｴ蜷医??uid縺ｫ縺ｯaccount::UID_GUEST(=0)縺悟?繧九??/span>
  * @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 + "_xnpaccount_session WHERE sid=" + unsignedIntToString(sid);
        syslog_printf( "sql=%s", sql.c_str() );
        return queryGetUnsignedInt( "sessionID2UID", sql, uid );
    }
}


/**
 * 
 * gid縺ｮ蟄伜惠繧偵メ繧ｧ繝?け.
 * DB縺ｮ繧｢繧ｯ繧ｻ繧ｹ螟ｱ謨励↑縺ｩ繧Ｇalse縺ｨ縺ｪ繧具ｼ?/span>
 * 
 * @param gid 繝√ぉ繝?け縺励◆縺ЖID
 * @return true 蟄伜惠縺吶ｋ
 * @return false 蟄伜惠縺励↑縺?/span>
 * 
 */
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 + "_xnpaccount_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縺ｮ繧｢繧ｯ繧ｻ繧ｹ螟ｱ謨励↑縺ｩ繧Ｇalse縺ｨ縺ｪ繧具ｼ?/span>
 * 
 * @param uid 繝√ぉ繝?け縺励◆縺ФID
 * @return true 蟄伜惠縺吶ｋ
 * @return false 蟄伜惠縺励↑縺?/span>
 * 
 */
static bool uidExists( userid_t uid )
{
    bool ret = false;
    string sql;
    SQLRETURN sqlcode;
    
    sql = "SELECT * FROM " + dbprefix + "_xnpaccount_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;
}


/**
 * 
 * 繝??繧ｿ繝吶?繧ｹ縺ｮ蛻晄悄蛹?/span>
 * 
 * @param dsn DSN
 * @param user 繝??繧ｿ繝吶?繧ｹ縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺吶ｋ繝ｦ繝ｼ繧ｶ蜷?/span>
 * @param password 荳願ｨ倥Θ繝ｼ繧ｶ縺ｮ繝代せ繝ｯ繝ｼ繝?/span>
 * @param dbname 繝?繝溘?
 * @param prefix XOOPS繝??繧ｿ繝吶?繧ｹ繝??繝悶Ν縺ｮPREFIX
 * @param dbtype DBTYPE_MYSQL or DBTYPE_SQLITE
 * @return RES_OK
 * @return RES_DB_INITIALIZE_ERROR
 * @return RES_DB_CONNECT_ERROR
 * @refer result_t
 */
result_t initializeDB( const char* dsn, const char* user, const char* password, const char* dbname, const char* prefix, dbtype_t type )
{
    SQLRETURN sqlcode;

    // 譌｢縺ｫ謗･邯壻ｸｭ縺ｪ繧峨?∽ｸ?譌ｦ蛻?妙
    if ( hdbc != NULL )
        SQLDisconnect( hdbc );
    
    dbprefix = prefix;
    dbtype = type;
    
    // 蛻晄悄蛹悶→謗･邯?/span>
//    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 縺ｨ縺励※謖ｯ闊槭≧繧医≧縺ｫ螻樊?ｧ繧定ｨｭ螳?/span>
    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遘剃ｻ･荳願ｦ√＠縺溘ｉ繧ｿ繧､繝?繧｢繧ｦ繝医☆繧玖ｨｭ螳?/span>
    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謗･邯壹′縺ゅｌ縺ｰ縲√◎繧後ｒ髢区叛縺吶ｋ縲?/span>
 * 
 * @param 縺ｪ縺?/span>
 * @return RES_OK
 */
result_t uninitializeDB()
{
    if ( hdbc != NULL ){
        SQLDisconnect( hdbc );
        hdbc = NULL;
    }
    return RES_OK;
}

/**
 * 
 * Platform繝ｦ繝ｼ繧ｶ謇ｿ隱咲憾諷句叙蠕?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param uid 迥ｶ諷九ｒ蜿門ｾ励＠縺溘＞繝ｦ繝ｼ繧ｶ縺ｮUID
 * @return true 謇ｿ隱肴ｸ医∩
 * @return false 譛ｪ謇ｿ隱?/span>
 * 
 */
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 + "_xnpaccount_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)縺ｮ謖?ｮ?/span>
 * @return RES_OK
 * @return RES_DB_QUERY_ERROR
 * @return RES_NO_SUCH_USER
 */
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;
    SQLRETURN sqlcode;
    result_t ret = RES_ERROR;
    
    sql = "UPDATE " + dbprefix + "_xnpaccount_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;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝域焚繧貞叙蠕励☆繧具ｼ?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @return 繧｢繧ｫ繧ｦ繝ｳ繝域焚
 * 
 */
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;    
    
    //繧｢繧ｫ繧ｦ繝ｳ繝域焚繧呈ｱゅａ繧?/span>
    sql = "SELECT COUNT(*) FROM " + dbprefix + "_xnpaccount_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;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝亥炎髯､
 * 繧ｰ繝ｫ繝ｼ繝励°繧峨?蜑企勁縺ｨ繝ｦ繝ｼ繧ｶ諠??ｱ縺ｮ蜑企勁繧定｡後↑縺?∪縺呻ｼ?/span>
 * 
 * @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 xnpaccount_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 xnpaccount_users
    sql = "DELETE FROM " + dbprefix + "_xnpaccount_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;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ蜿門ｾ?/span>
 * 
 * @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
 * 
 */
result_t getAccount( sessionid_t sid, userid_t uid, const account_t** acc )
{
    int len;
    static criteria c;
    result_t res = getAccounts( sid, &uid, 1, &c, acc, &len );
    if( len == 0 ) return RES_NO_SUCH_USER;
    return res;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ蜿門ｾ?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param uids 蜿門ｾ励＠縺溘＞繝ｦ繝ｼ繧ｶ縺ｮUID縺ｮ驟榊?
 * @param uidsLen uids驟榊?縺ｮ隕∫ｴ?謨ｰ
 * @param cri 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @param accounts 讀懃ｴ｢邨先棡縺ｮ驟榊?縺ｮ繝昴う繝ｳ繧ｿ繧呈嶌縺崎ｾｼ繧?蠑墓焚
 * @param accountsLen 讀懃ｴ｢邨先棡縺ｮ謨ｰ(驟榊?*accounts縺ｮ隕∫ｴ?謨ｰ)
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * 
 */
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 + "_xnpaccount_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;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝育匳骭ｲ.
 * 
 * 繝ｦ繝ｼ繧ｶ諠??ｱ繧偵ョ繝ｼ繧ｿ繝吶?繧ｹ縺ｫ逋ｻ骭ｲ縺励∪縺呻ｼ?/span>
 * 逋ｻ骭ｲ縺励◆繝ｦ繝ｼ繧ｶ諠??ｱ縺ｫ蟇ｾ蠢懊☆繧九Θ繝ｼ繧ｶID繧置id縺ｫ譬ｼ邏阪＠縺ｾ縺呻ｼ?/span>
 * 
 * @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;
    SQLRETURN sqlcode;
    result_t ret = RES_ERROR;
    
    /*
      1. insert user profile into xoops_users
      2. insert platform user profile into xnpaccount_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繧貞叙蠕励☆繧?/span>
                    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.xnpaccount縺ｮ繝ｦ繝ｼ繧ｶ繝??繝悶Ν縺ｫ谿九ｊ縺ｮ諠??ｱ繧呈嶌縺崎ｾｼ繧?
        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 + "_xnpaccount_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 = account -> getNoticeMailSince( );
                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 + "_xnpaccount_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縺ｮ譖ｸ縺肴鋤縺?/span>
                sql = "UPDATE " + dbprefix + "_xnpaccount_users SET private_index_id=" 
                  + unsignedIntToString(privateXID) + " WHERE uid=" + unsignedIntToString(*uid);
                ret = querySimple( "insertAccount", sql );
            }
        }
    }
    
    return ret;
}

/**
 * 
 * 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧貞､画峩縺吶ｋ.
 * 
 * 
 * @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;
    }
    
    //xnpaccount縺ｮ繝ｦ繝ｼ繧ｶ繝??繝悶Ν縺ｫ谿九ｊ縺ｮ諠??ｱ繧剃ｸ頑嶌縺阪☆繧?/span>
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        string sql;

        sql = "UPDATE " + dbprefix + "_xnpaccount_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 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @param uids 繝ｦ繝ｼ繧ｶ縺ｮUID縺ｮ驟榊?縺ｮ蜃ｺ蜉帛?
 * @param uidsLen uids驟榊?縺ｮ隕∫ｴ?謨ｰ縺ｮ蜃ｺ蜉帛?
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * 
 */
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;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            

    sql = "SELECT uid FROM " + dbprefix + "_xnpaccount_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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝玲焚繧定ｿ斐☆.
 * 荳肴ｭ｣縺ｪ繧ｻ繝?す繝ｧ繝ｳID縺ｪ繧?繧定ｿ斐☆.
 * 
 * @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;
    
    //繧ｰ繝ｫ繝ｼ繝玲焚繧呈ｱゅａ繧?/span>
    sql = "SELECT COUNT(*) FROM " + dbprefix + "_xnpaccount_groups";
    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繧貞叙蠕励☆繧?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param uid 繝ｦ繝ｼ繧ｶ縺ｮUID
 * @param cri 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @param gids 繧ｰ繝ｫ繝ｼ繝悠D縺ｮ驟榊?縺ｮ蜃ｺ蜉帛?
 * @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
 * 
 */
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 + "_xnpaccount_groups_users_link";
    sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
    sql += criteria2str( cri );
    if( countResultRows( sql.c_str(), &count ) == RES_OK ){
        *gidsLen = count;
        dst = new groupid_t[ *gidsLen ];
        *gids = dst;
    }else{
        return RES_ERROR;
    }
    
    //謇?螻槭☆繧九げ繝ｫ繝ｼ繝励?譛?螟ｧ蛟区焚繧呈ｱゅａ繧?/span>
    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 + "_xnpaccount_groups_users_link";
                    sql += " WHERE uid=" + string( unsignedIntToString( uid ) );
                    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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅?ｨｩ髯仙撫蜷医○.
 * 繝ｦ繝ｼ繧ｶ縺ｫ繝ｫ繝ｼ繝励?邂｡逅?ｨｩ髯舌′縺ゅｋ縺?繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???〒縺ゅｋ縺?繧貞撫縺?粋繧上○繧?
 * 繝ｦ繝ｼ繧ｶ繧?げ繝ｫ繝ｼ繝励′蟄伜惠縺励↑縺?↑縺ｩ縺ｮ逡ｰ蟶ｸ縺ｮ蝣ｴ蜷茨ｼ掲alse繧定ｿ斐☆.
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 繧ｰ繝ｫ繝ｼ繝励?UID
 * @param uid 繝ｦ繝ｼ繧ｶ縺ｮUID
 * @return true 邂｡逅?ｨｩ髯舌≠繧?/span>
 * @return false 邂｡逅?ｨｩ髯舌↑縺暦ｼ後∪縺溘?荳肴?
 * 
 */
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 + "_xnpaccount_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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝悠D荳?隕ｧ.
 * 逋ｻ骭ｲ縺輔ｌ縺ｦ縺?ｋ繧ｰ繝ｫ繝ｼ繝励?ID荳?隕ｧ繧貞叙蠕励☆繧?
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param cri 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @param gids 繧ｰ繝ｫ繝ｼ繝悠D縺ｮ驟榊?縺ｮ蜃ｺ蜉帛?
 * @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;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            
    sql = "SELECT gid FROM " + dbprefix + "_xnpaccount_groups ";
    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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???D繧貞叙蠕励☆繧?
 * 縺ゅｋ繧ｰ繝ｫ繝ｼ繝励?邂｡逅????繝ｦ繝ｼ繧ｶID繧貞叙蠕励☆繧?
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 蝠上＞蜷医ｏ縺帙ｋ繧ｰ繝ｫ繝ｼ繝励ｒID縺ｧ謖?ｮ壹☆繧?/span>
 * @param cri 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @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;
    SQLRETURN sqlcode;
    SQLLEN count = 0;
            
    sql = "SELECT uid FROM " + dbprefix + "_xnpaccount_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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝玲園螻槭Θ繝ｼ繧ｶ蜑企勁.
 * 繧ｰ繝ｫ繝ｼ繝励↓謇?螻槭☆繧九Θ繝ｼ繧ｶ繧抵ｼ後げ繝ｫ繝ｼ繝励°繧牙炎髯､縺吶ｋ.
 * 繝?ヵ繧ｩ繝ｫ繝医げ繝ｫ繝ｼ繝励°繧峨?蜑企勁縺ｧ縺阪↑縺?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 縺ｩ縺ｮ繧ｰ繝ｫ繝ｼ繝励°繧牙炎髯､縺吶ｋ縺九ｒ謖?ｮ壹☆繧九げ繝ｫ繝ｼ繝悠D
 * @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 );
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝玲園螻槭Θ繝ｼ繧ｶ蜑企勁.
 * 繧ｰ繝ｫ繝ｼ繝励↓謇?螻槭☆繧九Θ繝ｼ繧ｶ繧抵ｼ後げ繝ｫ繝ｼ繝励°繧牙炎髯､縺吶ｋ.
 * 繝?ヵ繧ｩ繝ｫ繝医げ繝ｫ繝ｼ繝励°繧峨ｂ蜑企勁縺ｧ縺阪ｋ轤ｹ縺鯉ｼ慧eleteMember縺ｨ逡ｰ縺ｪ繧?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 縺ｩ縺ｮ繧ｰ繝ｫ繝ｼ繝励°繧牙炎髯､縺吶ｋ縺九ｒ謖?ｮ壹☆繧九げ繝ｫ繝ｼ繝悠D
 * @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 + "_xnpaccount_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 邂｡逅???ｨｩ髯舌ｒ荳弱∴繧九↑繧液rue
 * @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;
    SQLRETURN sqlcode;
    
    //繝｡繝ｳ繝舌?繧定ｿｽ蜉?
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        sql = "INSERT INTO " + dbprefix + "_xnpaccount_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繧貞叙蠕励☆繧?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 縺ｩ縺ｮ繧ｰ繝ｫ繝ｼ繝励?謇?螻槭Θ繝ｼ繧ｶ繧貞撫縺?粋繧上○繧九°繧偵げ繝ｫ繝ｼ繝励ｒID縺ｧ謖?ｮ?/span>
 * @param cri 邨先棡縺ｮ遽?峇謖?ｮ夲ｼ後た繝ｼ繝域擅莉ｶ謖?ｮ?/span>
 * @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 + "_xnpaccount_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 + "_xnpaccount_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縺ｧ謖?ｮ?/span>
 * @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 + "_xnpaccount_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;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝礼匳骭ｲ. 
 * 繧ｰ繝ｫ繝ｼ繝励?諠??ｱ繧偵ョ繝ｼ繧ｿ繝吶?繧ｹ縺ｫ險倬鹸縺吶ｋ??/span>
 * 逋ｻ骭ｲ縺励◆繧ｰ繝ｫ繝ｼ繝励↓蟇ｾ蠢懊☆繧九げ繝ｫ繝ｼ繝悠D繧暖id縺ｫ譬ｼ邏阪☆繧具ｼ?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param group 逋ｻ骭ｲ縺励◆縺?げ繝ｫ繝ｼ繝励?諠??ｱ
 * @param gid 逋ｻ骭ｲ縺励◆繧ｰ繝ｫ繝ｼ繝励↓蟇ｾ蠢懊☆繧九げ繝ｫ繝ｼ繝悠D
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * 
 */
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;
    SQLRETURN sqlcode;
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        sql = "INSERT INTO " + dbprefix + "_xnpaccount_groups ( gname, gdesc, group_item_number_limit, group_index_number_limit, group_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_CHAR, SQL_LONGVARCHAR, XNP_GROUP_GNAME_LEN, 0, gname, 0, &cbGname );
            SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_GROUP_GDESC_LEN, 0, gdesc, 0, &cbGdesc );
            SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &item_number_limit, 0, &cbItem_number_limit);
            SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &index_number_limit, 0, &cbIndex_number_limit);
            SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &item_storage_limit, 0, &cbItem_storage_limit);
            strncpy2( (char*)gname, group -> getGname( ), XNP_GROUP_GNAME_LEN );
            strncpy2( (char*)gdesc, group -> getDesc( ), XNP_GROUP_GDESC_LEN );
            item_number_limit = group -> getItemNumberLimit( );
            index_number_limit = group -> getIndexNumberLimit( );
            item_storage_limit = group -> getItemStorageLimit( );
            if( ( sqlcode = SQLExecute( hstmt ) ) == SQL_SUCCESS ){
                SQLLEN count = 0;
                if( ( sqlcode = SQLRowCount( hstmt, &count ) ) == SQL_SUCCESS && count > 0 ){
                    //繧ｰ繝ｫ繝ｼ繝悠D繧貞叙蠕励☆繧?/span>
                    if( dbtype == DBTYPE_MYSQL ){
                        sql = "SELECT LAST_INSERT_ID()";
                    }else if( dbtype == DBTYPE_SQLITE ){
                        sql = "SELECT LAST_INSERT_ROWID()";
                    }
                    ret = queryGetUnsignedInt( "insertGroup", sql, (unsigned int*)gid );
                }else{
                    string s( "SQLRowCount in insertGroup sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }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 );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in insertGroup" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    
    // 
    if ( ret == RES_OK ){
        //group index繧剃ｽ懈?
        
        //group index逕ｨ縺ｮsort_num逕滓?
        string sql = "SELECT MAX(sort_number) FROM " + 
          dbprefix + "_xnpaccount_index WHERE parent_index_id=" + unsignedIntToString(item::IID_ROOT) + 
          " AND (open_level=" + unsignedIntToString(index::OL_GROUP_ONLY) +
            " OR open_level=" + unsignedIntToString(index::OL_PUBLIC) + ")";
        unsigned int sortNumber;
        ret = queryGetUnsignedInt( "insertGroup", sql, &sortNumber );
        sortNumber++;
        if ( ret == RES_OK ){
            // group index菴懈?
            index_t index;
            userid_t uid;
            ret = sessionID2UID( sid, &uid );
            if ( ret == RES_OK ){
                index.setItemTypeID(item::ITID_INDEX);
                index.setContributorUID(uid);
                index.setParentIndexID(item::IID_ROOT);
                index.setOwnerGID(*gid);
                index.setOpenLevel(index::OL_GROUP_ONLY);
                index.setSortNumber(sortNumber);
                index.setTitle(group->getGname());
                indexid_t groupXID;
                ret = insertIndexInternal( sid, &index, &groupXID );
                if ( ret == RES_OK ){
                    // xnpaccuont_groups縺ｮgroup_index_id縺ｮ譖ｸ縺肴鋤縺?/span>
                    sql = "UPDATE " + dbprefix + "_xnpaccount_groups SET group_index_id=" 
                      + unsignedIntToString(groupXID) + " WHERE gid=" + unsignedIntToString(*gid);
                    ret = querySimple( "insertGroup", sql );
                }
            }
        }
    }
    
    return ret;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ繧貞､画峩縺吶ｋ
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param group 譁ｰ縺励＞繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ
 * @return RES_OK
 * @return RES_ERROR
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * 
 */
result_t updateGroup( sessionid_t sid, const group_t* group )
{
    if( hdbc == NULL ) return RES_DB_NOT_INITIALIZED;
    if( group == NULL ) return RES_ERROR;
    if( !isValidSessionID( sid ) ) return RES_NO_SUCH_SESSION;
    if( !gidExists( group -> getGID( ) ) ) return RES_NO_SUCH_GROUP;
    
    result_t ret = RES_ERROR;
    string sql;
    SQLCHAR gname[XNP_GROUP_GNAME_LEN+1], gdesc[XNP_GROUP_GDESC_LEN+1];
    SQLLEN cbGname = SQL_NTS, cbGdesc = SQL_NTS;
    SQLRETURN sqlcode;
    
    if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
        sql = "UPDATE " + dbprefix + "_xnpaccount_groups SET gname=?, gdesc=?, ";
        sql += "group_item_number_limit=" + unsignedIntToString( group -> getItemNumberLimit( ) ) + " ,";
        sql += "group_index_number_limit=" + unsignedIntToString( group -> getIndexNumberLimit( ) ) + " ,";
        sql += "group_item_storage_limit=" + doubleToString( group -> getItemStorageLimit( ) ) + " ";
        sql += "WHERE gid=" + string( unsignedIntToString( group -> getGID( ) ) );
        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 );
            SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_LONGVARCHAR, XNP_GROUP_GDESC_LEN, 0, gdesc, 0, &cbGdesc );
            strncpy2( (char*)gname, group -> getGname( ), XNP_GROUP_GNAME_LEN );
            strncpy2( (char*)gdesc, group -> getDesc( ), XNP_GROUP_GDESC_LEN );
            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 updateGroup sql=" );
                    s += string( sql );
                    setLastErrorString( s.c_str( ) );
                    ret = RES_DB_QUERY_ERROR;
                }
            }else{
                string s( "SQLExecute in updateGroup " );
                s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_DB_QUERY_ERROR;
            }
        }else{
            setLastErrorString( "SQLPrepare in updateGroup sql=" );
            ret = RES_ERROR;
        }
        SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
    }else{
        string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateGroup" );
        s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
        setLastErrorString( s.c_str( ) );
        ret = RES_ERROR;
    }
    
    if( ret == RES_OK ){
        // update縺吶∋縺絞ndex_id繧貞ｾ励ｋ
        sql = "SELECT group_index_id from " + dbprefix + "_xnpaccount_groups as tg "
          " left join " + dbprefix + "_xnpaccount_item_basic as ti on tg.group_index_id = ti.item_id "
          " left join " + dbprefix + "_xnpaccount_index as tx on ti.item_id = tx.index_id "
          " where tg.gid=" +  unsignedIntToString(group->getGID()) + 
          "  and ti.item_type_id=" + unsignedIntToString(item::ITID_INDEX) +
          "  and tx.parent_index_id=" + unsignedIntToString(item::IID_ROOT);
        indexid_t xid;
        ret = queryGetUnsignedInt( "updateGroup",  sql, &xid );
        
        if ( ret == RES_OK ){
            if( ( sqlcode = SQLAllocHandle( SQL_HANDLE_STMT, hdbc, &hstmt ) ) == SQL_SUCCESS ) {
                sql = "UPDATE " + dbprefix + "_xnpaccount_item_basic set title=? "
                    "WHERE item_id=" + unsignedIntToString(xid);
                sqlcode = SQLPrepare(hstmt, (SQLCHAR*)sql.c_str(), SQL_NTS);
                if( sqlcode == SQL_SUCCESS || sqlcode == SQL_SUCCESS_WITH_INFO ){
                    cbGname = SQL_NTS;
                    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 && count > 0 ){
                            ret = RES_OK;
                        }else{
                            string s( "SQLRowCount in updateGroup sql=" );
                            s += string( sql );
                            setLastErrorString( s.c_str( ) );
                            ret = RES_DB_QUERY_ERROR;
                        }
                    }else{
                        string s( "SQLExecute in updateGroup " );
                        s += odbcDiagString( SQL_HANDLE_STMT, hstmt, sqlcode );
                        setLastErrorString( s.c_str( ) );
                        ret = RES_DB_QUERY_ERROR;
                    }
                }else{
                    setLastErrorString( "SQLPrepare in updateGroup sql=" );
                    ret = RES_ERROR;
                }
                SQLFreeHandle( SQL_HANDLE_STMT, hstmt );
            }else{
                string s( "SQLAllocHandle(SQL_HANDLE_STMT,...) in updateGroup" );
                s += odbcDiagString( SQL_HANDLE_DBC, hdbc, sqlcode );
                setLastErrorString( s.c_str( ) );
                ret = RES_ERROR;
            }
        }
    }
    return RES_OK;
}

/**
 * 
 * 繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ蜿門ｾ?/span>
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gid 蜿門ｾ励＠縺溘＞繧ｰ繝ｫ繝ｼ繝励?GID
 * @param group 蜿門ｾ励＠縺溘げ繝ｫ繝ｼ繝玲ュ蝣ｱ縺ｮ繧｢繝峨Ξ繧ｹ繧呈嶌縺崎ｾｼ繧?繝昴う繝ｳ繧ｿ
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_NO_SUCH_GROUP
 * @return RES_DB_QUERY_ERROR
 * 
 */
result_t getGroup( sessionid_t sid, groupid_t gid, const group_t** group )
{
    int len;
    static criteria c;
    result_t res = getGroups( sid, &gid, 1, &c, group, &len );
    if( len == 0 ) return RES_NO_SUCH_GROUP;
    return res;
}

/**
 * 
 * 隍?焚縺ｮ繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ繧剃ｸ?蠎ｦ縺ｫ蜿門ｾ励☆繧?
 * 
 * @param sid 繧ｻ繝?す繝ｧ繝ｳID
 * @param gids 蜿門ｾ励＠縺溘＞繧ｰ繝ｫ繝ｼ繝励?GID縺ｮ驟榊?
 * @param gidsLen gids驟榊?縺ｮ隕∫ｴ?謨ｰ
 * @param cri 邨先棡縺ｮ蜿門ｾ礼ｯ?峇?後た繝ｼ繝域擅莉ｶ繧呈欠螳?/span>
 * @param groups 蜿門ｾ礼ｵ先棡縺ｮ繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ縺ｮ驟榊?縺ｮ繧｢繝峨Ξ繧ｹ繧呈嶌縺崎ｾｼ繧?繝昴う繝ｳ繧ｿ
 * @param groupsLen 蜿門ｾ礼ｵ先棡縺ｮ驟榊?縺ｮ隕∫ｴ?謨ｰ
 * @return RES_OK
 * @return RES_DB_NOT_INITIALIZED
 * @return RES_NO_SUCH_SESSION
 * @return RES_DB_QUERY_ERROR
 * 
 */
result_t getGroups( sessionid_t sid, groupid_t* gids, int 