transactd 3.1.0 → 3.2.0

data/source/bzs/db/engine/mysql/mysqlProtocol.cpp

@@ -0,0 +1,425 @@
+/* =================================================================
+ Copyright (C) 2016 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+/* MySQL 5.5 and Mariadb are no-rtti */
+#ifdef __GNUC__
+# pragma implementation "mysqlInternal.h" 
+#endif
+
+#include "mysqlProtocol.h"
+#include "mysqlThd.h"
+#include <bzs/env/crosscompile.h>
+#include <bzs/db/protocol/tdap/tdapcapi.h>
+
+#if defined(USE_BINLOG_VAR) && (!defined(MARIADB_BASE_VERSION) &&  MYSQL_VERSION_ID > 50600)
+#  include "sql/binlog.h"
+#endif
+
+//----------------------------------------------------------------------
+//  Implement dummyProtocol
+//----------------------------------------------------------------------
+#if defined(MYSQL_5_7)
+#  define Protocol_mysql Protocol
+#  define CP_PROTOCOL PROTOCOL_PLUGIN
+#else
+#  define Protocol_mysql Protocol
+#  define CP_PROTOCOL PROTOCOL_BINARY
+#endif
+
+
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+
+class dummyProtocol : public Protocol_mysql
+{
+	THD* m_thd;
+    Protocol_mysql* m_backup;
+    
+public:
+#if defined(MYSQL_5_7)
+	inline dummyProtocol(THD *thd_arg) : Protocol_mysql()
+	{
+		m_thd = thd_arg;
+        m_backup = m_thd->get_protocol();
+		m_thd->set_protocol(this);
+	}
+	inline virtual ~dummyProtocol()
+    {
+        m_thd->set_protocol(m_backup);    
+    }
+#else
+	inline dummyProtocol(THD *thd_arg) : Protocol_mysql(thd_arg)
+	{
+		m_thd = thd_arg;
+        m_backup = m_thd->protocol;
+        m_thd->protocol = this;
+	}
+    inline virtual ~dummyProtocol()
+    {
+        m_thd->protocol = m_backup;       
+    }
+#endif
+    bool send_result_set_metadata(List<Item> *list, uint flags){return false;}
+    virtual bool write(){return false;};
+    virtual void prepare_for_resend(){}
+    virtual bool store_null(){return false;}
+    virtual bool store_tiny(longlong from){return store_longlong(from, false);}
+    virtual bool store_short(longlong from){return store_longlong(from, false);}
+    virtual bool store_long(longlong from){return store_longlong(from, false);}
+    virtual bool store_decimal(const my_decimal *){return false;}
+    virtual bool store(float from, uint32 decimals, String *buffer){return false;}
+    virtual bool store(double from, uint32 decimals, String *buffer){return false;}
+    virtual bool store(MYSQL_TIME *time, uint precision){return false;}
+    virtual bool store_date(MYSQL_TIME *time){return false;}
+    virtual bool store_time(MYSQL_TIME *time, uint precision){return false;}
+    virtual bool store(Field *field){return false;}
+    virtual bool store(const char *from, size_t length, const CHARSET_INFO *fromcs,
+                     const CHARSET_INFO* /*tocs*/){return false;}
+
+    virtual bool send_out_parameters(List<Item_param> *sp_params){return false;}
+	virtual Protocol::enum_protocol_type type(void){ return CP_PROTOCOL; };
+#ifdef MARIADB_BASE_VERSION      //Mariadb 5.5 10.0 10.1
+    virtual bool store(MYSQL_TIME *time, int decimals){return false;}
+    virtual bool store_time(MYSQL_TIME *time, int decimals){ return false;}
+#elif defined(MYSQL_5_5)
+    virtual bool store_time(MYSQL_TIME *time){return true;};
+    virtual bool store(MYSQL_TIME *time){return true;}
+    virtual bool store(const char *from, size_t length, 
+        CHARSET_INFO *fromcs, CHARSET_INFO *tocs){return false;}
+#elif defined(MYSQL_5_7) 
+	bool store_decimal(const my_decimal *, uint, uint){ return true; }
+	bool store(Proto_field *){ return true; }
+	void start_row(){}
+	int read_packet(void){ return 0; }
+	int get_command(COM_DATA *, enum_server_command *){ return m_thd->lex->sql_command; }
+	enum_vio_type connection_type(void){ return VIO_TYPE_PLUGIN; }
+	ulong get_client_capabilities(void){ return 0; }
+	bool has_client_capability(unsigned long){ return false; }
+	bool connection_alive(void){ return false; }
+	bool end_row(void){ return false; }
+	void abort_row(void){}
+	void end_partial_result_set(void){}
+	int shutdown(bool){ return 0; }
+	SSL_handle get_ssl(void){ return NULL; }
+	uint get_rw_status(void){ return 0; }
+	bool get_compression(void){ return false; }
+	bool start_result_metadata(uint, uint, const CHARSET_INFO *){ return false; }
+	bool send_field_metadata(Send_field *, const CHARSET_INFO *){ return false; }
+	bool end_result_metadata(void){ return false; }
+	bool send_ok(uint, uint, ulonglong, ulonglong, const char *){ return false; }
+	bool send_eof(uint, uint){ return false; }
+	bool send_error(uint, const char *, const char *){ return false; }
+#endif
+};
+
+//----------------------------------------------------------------------
+//  class masterStatus for windows mysql 5.6 only
+//----------------------------------------------------------------------
+#if defined(NOTUSE_BINLOG_VAR)
+class masterStatus : public dummyProtocol
+{
+    binlogPos* m_bpos;
+    bool m_writed;
+public:
+    inline masterStatus(THD *thd_arg, binlogPos* bpos) : 
+        dummyProtocol(thd_arg), m_bpos(bpos), m_writed(false) {}
+    bool store_longlong(longlong from, bool unsigned_flag)
+    {
+        m_bpos->pos = (ulonglong)from;
+        m_bpos->type = REPL_POSTYPE_POS;
+        return false;
+    }
+
+#if (MYSQL_VERSION_ID < 50600 || defined(MARIADB_BASE_VERSION)) // mariadb 5.5 
+    bool store(const char *from, size_t length, CHARSET_INFO *cs)
+    {
+        if (!m_writed)
+        {
+			strncpy(m_bpos->filename, from, BINLOGNAME_SIZE); 
+            m_writed = true;
+        }
+        return false;
+    }
+#else
+    bool store(const char *from, size_t length, const CHARSET_INFO *cs)
+    {
+        if (!m_writed)
+        {
+			strncpy(m_bpos->filename, from, BINLOGNAME_SIZE);
+            m_writed = true;
+        }
+        return false;
+    }
+#endif
+};
+#endif // NOTUSE_BINLOG_VAR
+
+//----------------------------------------------------------------------
+//  class safe_commit_lock  commit lock for binlogPos
+//----------------------------------------------------------------------
+safe_commit_lock::safe_commit_lock(THD* thd): m_thd(thd), m_commits_lock(NULL)
+{
+
+}
+
+bool safe_commit_lock::lock()
+{
+    if (m_thd)
+    {
+        MDL_request mdl_request;
+		#if ((MYSQL_VERSION_NUM > 50700) && !defined(MARIADB_BASE_VERSION))
+		mdl_request.init_with_source(MDL_key::COMMIT, "", "", MDL_SHARED, MDL_EXPLICIT, __FILE__, __LINE__);
+		#else
+		mdl_request.init(MDL_key::COMMIT, "", "", MDL_SHARED, MDL_EXPLICIT);
+		#endif
+        if (m_thd->mdl_context.acquire_lock(&mdl_request,
+                                    m_thd->variables.lock_wait_timeout))
+            return false;
+        m_commits_lock = mdl_request.ticket;
+    }
+    return true;
+}
+
+safe_commit_lock::~safe_commit_lock()
+{
+    if (m_commits_lock)
+    {
+        m_thd->mdl_context.release_lock(m_commits_lock);
+        m_commits_lock= NULL;
+    }
+}
+
+
+#ifdef NOTUSE_BINLOG_VAR 
+    inline short getBinlogPosInternal(THD* currentThd, binlogPos* bpos, THD* tmpThd)
+    {
+        short result = 0;
+        {
+            attachThd(tmpThd);
+            copyGrant(tmpThd, currentThd, NULL);
+            masterStatus p(tmpThd, bpos); 
+            cp_query_command(tmpThd, "show master status");
+            if (tmpThd->is_error())
+                result = tmpThd->cp_get_sql_error();
+            cp_lex_clear(tmpThd);
+        }
+        attachThd(currentThd);
+        return result;
+    }
+#endif
+
+#ifdef USE_BINLOG_GTID
+    inline short getBinlogPosInternal(THD* currentThd, binlogPos* bpos, THD* /*tmpThd*/)
+    {
+        if (mysql_bin_log.is_open())
+        {
+            rpl_gtid gtid;
+            bpos->type = REPL_POSTYPE_MARIA_GTID;
+            if (mysql_bin_log.lookup_domain_in_binlog_state(currentThd->variables.gtid_domain_id,  &gtid))
+            {
+                sprintf_s(bpos->gtid, GTID_SIZE, "%u-%u-%llu", gtid.domain_id, gtid.server_id, gtid.seq_no); 
+                size_t dir_len = dirname_length(mysql_bin_log.get_log_fname());
+			    strncpy(bpos->filename, mysql_bin_log.get_log_fname() + dir_len, BINLOGNAME_SIZE);
+			    bpos->pos = my_b_tell(mysql_bin_log.get_log_file());
+			    bpos->filename[BINLOGNAME_SIZE-1] = 0x00;
+            }
+        }
+        return 0;
+    }
+#endif
+
+#ifdef USE_BINLOG_VAR
+    // Linux MySQL can access to the mysql_bin_log variable
+    inline short getBinlogPosInternal(THD* , binlogPos* bpos, THD* /*tmpThd*/)
+    {
+        if (mysql_bin_log.is_open())
+        {
+			size_t dir_len = dirname_length(mysql_bin_log.get_log_fname());
+			strncpy(bpos->filename, mysql_bin_log.get_log_fname() + dir_len, BINLOGNAME_SIZE);
+			bpos->pos = my_b_tell(mysql_bin_log.get_log_file());
+			bpos->filename[BINLOGNAME_SIZE-1] = 0x00;
+            bpos->type = REPL_POSTYPE_POS;
+        }
+        return 0;
+    }
+#endif //USE_BINLOG_VAR
+
+short getBinlogPos(THD* thd, binlogPos* bpos, THD* tmpThd)
+{
+    #ifndef NOTUSE_BINLOG_VAR
+    safe_mysql_mutex_lock lck(mysql_bin_log.get_log_lock());
+    #endif
+    return getBinlogPosInternal(thd, bpos, tmpThd);
+}
+
+int execSql(THD* thd, const char* sql)
+{
+    thd->variables.lock_wait_timeout = OPEN_TABLE_TIMEOUT_SEC;
+    thd->clear_error();
+	int result = cp_query_command(thd, (char*)sql);
+    if (thd->is_error())
+        result = thd->cp_get_sql_error();
+    cp_lex_clear(thd); // reset values for insert
+    return result;
+}
+
+//----------------------------------------------------------------------
+//  slaveStatus  
+//----------------------------------------------------------------------
+using namespace bzs::db::transactd;
+class slaveStatus : public dummyProtocol
+{
+    connection::records& m_records;
+    connection::record& getRec()
+    {
+        m_records.push_back(connection::record());
+        return m_records[m_records.size() - 1];
+    }
+public:
+    inline slaveStatus(THD *thd_arg, connection::records& recs) : 
+        dummyProtocol(thd_arg), m_records(recs)
+    {
+        m_records.clear();   
+    }
+    bool store_longlong(longlong from, bool unsigned_flag)
+    {
+        connection::record& rec = getRec();
+        rec.type = 0;
+        rec.longValue = from; 
+        return false;
+    }
+    bool store_null()
+    {
+        connection::record& rec = getRec();
+        rec.type = 1;
+        strncpy(rec.value, "NULL", CON_REC_VALUE_SIZE); 
+        return false;
+    }
+#if (MYSQL_VERSION_ID < 50600 || defined(MARIADB_BASE_VERSION)) // MySQL 5.5 
+    bool store(const char *from, size_t length, CHARSET_INFO *cs)
+    {
+        connection::record& rec = getRec();
+        rec.type = 1;
+        if (length && from)
+            strncpy(rec.value, from, CON_REC_VALUE_SIZE); 
+        return false;
+    }
+#else
+    bool store(const char *from, size_t length, const CHARSET_INFO *cs)
+    {
+        connection::record& rec = getRec();
+        rec.type = 1;
+        if (length && from)
+            strncpy(rec.value, from, CON_REC_VALUE_SIZE); 
+        return false;
+    }
+#endif
+};
+
+int getSlaveStatus(THD* thd, connection::records& recs)
+{
+	slaveStatus ss(thd, recs);
+	return execSql(thd, "show slave status");
+}
+
+#pragma GCC diagnostic warning "-Woverloaded-virtual"
+
+
+//----------------------------------------------------------------------
+//  database list
+//----------------------------------------------------------------------
+inline void appenDbList(connection::records& recs, LEX_STRING* db_name)
+{
+    recs.push_back(connection::record());
+    connection::record& rec = recs[recs.size() - 1];
+    strncpy(rec.name, db_name->str, 64);
+    rec.name[64] = 0x00;
+}
+
+void readDbList(THD* thd, connection::records& recs)
+{
+    SQL_Strings files;
+    db_list(thd, &files);
+#if (defined(MARIADB_10_0) || defined(MARIADB_10_1))
+    for (int i = 0; i < (int)files.elements(); ++i)
+        appenDbList(recs, files.at(i));
+#else
+    List_iterator_fast<LEX_STRING> it(files);
+    LEX_STRING* db_name;
+    while ((db_name = it++))
+        appenDbList(recs, db_name);
+#endif
+}
+
+//----------------------------------------------------------------------
+//  security
+//----------------------------------------------------------------------
+
+bool setGrant(THD* thd, const char* host, const char* user,  const char* db)
+{
+    // sctx->master_access and sctx->db_access
+    return (acl_getroot(cp_security_ctx(thd), cp_strdup(user, MYF(0)),
+		cp_strdup(host, MYF(0)), cp_strdup(host, MYF(0)), (char*)db)) == false;
+}
+
+bool copyGrant(THD* thd, THD* thdSrc, const char* db)
+{
+    Security_context* sctx = cp_security_ctx(thdSrc);
+	if (sctx->cp_master_accsess() == (ulong)~NO_ACCESS)
+    {
+        cp_security_ctx(thd)->skip_grants();
+        return true;
+    }
+	return setGrant(thd, sctx->cp_priv_host(), sctx->cp_priv_user(), db);
+}
+
+void setDbName(THD* thd, const char* name)
+{
+	cp_set_db(thd, name);
+}
+
+/*
+class safe_global_read_lock
+{
+    THD* m_thd;
+public:
+    safe_global_read_lock(THD* thd): m_thd(thd){}
+    bool lock()
+    {
+        if (m_thd->global_read_lock.lock_global_read_lock(m_thd))
+        {
+            m_thd = NULL;
+            return false;
+        }
+        #ifdef NOTUSE_BINLOG_VAR
+        close_cached_tables(NULL, NULL, FALSE , 50000000L);
+        if (m_thd->global_read_lock.make_global_read_lock_block_commit(m_thd))
+        {
+            m_thd->global_read_lock.unlock_global_read_lock(m_thd);
+            m_thd = NULL;
+            return false;
+        }
+        #endif
+        return true;
+    }
+    ~safe_global_read_lock()
+    {
+        if (m_thd)
+            m_thd->global_read_lock.unlock_global_read_lock(m_thd);
+    }
+};*/
+

data/source/bzs/db/engine/mysql/mysqlProtocol.h

@@ -0,0 +1,72 @@
+#ifndef BZS_DB_ENGINE_MYSQL_MYSQLPROTOCOL_H
+#define BZS_DB_ENGINE_MYSQL_MYSQLPROTOCOL_H
+/* =================================================================
+ Copyright (C) 2016 BizStation Corp All rights reserved.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ ================================================================= */
+#include "mysqlInternal.h"
+#include <bzs/env/compiler.h>
+#include <bzs/db/transactd/connectionRecord.h>
+
+
+#if (MYSQL_VERSION_ID > 100000)
+#  define USE_BINLOG_GTID     1  // like 0-1-50
+#elif (!defined(_WIN32) || MYSQL_VERSION_ID > 50700 || MYSQL_VERSION_ID < 50600) // Linux or MySQL 5.5 5.7
+#  define USE_BINLOG_VAR      1  
+#else // MySQL 5.6  on windows On windows MySQL 5.6 can not access mysql_bin_log variable
+#  define NOTUSE_BINLOG_VAR   1  
+#endif
+
+
+// REPL_POS_TYPE
+#define BINLOGNAME_SIZE                 119
+#define GTID_SIZE                       64
+
+#define REPL_POSTYPE_MARIA_GTID         1  // see tdapapi.h
+#define REPL_POSTYPE_POS                2  // see tdapapi.h
+
+#define OPEN_TABLE_TIMEOUT_SEC 2
+
+pragma_pack1
+struct binlogPos
+{
+    my_off_t pos;
+    char type;
+    char filename[BINLOGNAME_SIZE];
+    char gtid[GTID_SIZE];
+};
+pragma_pop
+
+class safe_commit_lock
+{
+    THD* m_thd;
+    MDL_ticket* m_commits_lock;
+public:
+    safe_commit_lock(THD* thd);
+    bool lock();
+    ~safe_commit_lock();
+};
+
+short getBinlogPos(THD* thd, binlogPos* pos, THD* tmpThd);
+int getSlaveStatus(THD* thd, bzs::db::transactd::connection::records& recs);
+int execSql(THD* thd, const char* sql);
+void readDbList(THD* thd, bzs::db::transactd::connection::records& recs);
+bool setGrant(THD* thd, const char* host, const char* user,  const char* db);
+bool copyGrant(THD* thd, THD* thdSrc, const char* db);
+void setDbName(THD* thd, const char* name);
+
+#endif // BZS_DB_ENGINE_MYSQL_MYSQLPROTOCOL_H

data/source/bzs/db/engine/mysql/mysqlThd.cpp

@@ -151,8 +151,6 @@ THD* buildTHD()
               g_lock_wait_timeout);
 	cp_query_command(thd, tmp);
 
-	
-	cp_set_db(thd, td_strdup("bizstation", MYF(0)));
     if (thd->variables.sql_log_bin)
         thd->set_current_stmt_binlog_format_row();
     return thd;
@@ -192,8 +190,12 @@ THD* createThdForThread()
 
 void deleteThdForThread(THD* thd)
 {
-    cp_restore_globals(thd);
-	cp_thd_release_resources(thd);
-	cp_dec_dbcount(thd);
-    releaseTHD(thd);
+    try
+    {
+        cp_restore_globals(thd);
+	    cp_thd_release_resources(thd);
+	    cp_dec_dbcount(thd);
+        releaseTHD(thd);
+    }
+    catch(...) {};
 }

data/source/bzs/db/protocol/hs/hsCommandExecuter.cpp

@@ -234,6 +234,10 @@ inline void setKeyValues(request& req, engine::mysql::table* tb, int index)
         tb->setKeyValues(req.table.key.values, -1);
 }
 
+dbExecuter::dbExecuter(netsvc::server::IAppModule* mod)
+    :engine::mysql::dbManager(mod){}
+
+
 void dbExecuter::doRecordOperation(request& req, engine::mysql::table* tb,
                                    resultBuffer& buf, changeFunc func)
 {
@@ -307,7 +311,7 @@ int dbExecuter::commandExec(std::vector<request>& requests,
             checkNewHandle(req.handle);
             bool created;
             database* db = getDatabase(req.db.name, 0 /*cid*/, created);
-            m_tb = db->openTable(req.table.name, req.table.openMode, NULL);
+            m_tb = db->openTable(req.table.name, req.table.openMode, NULL, "");
             if (m_tb)
             {
                 addHandle(getDatabaseID(0 /*cid*/), m_tb->id(), req.handle);
@@ -570,8 +574,8 @@ inline void setFilterVal(const std::string& src, int& parseMode, request* req)
     parseMode = PARSEREAD_FL_TYPE;
 }
 
-commandExecuter::commandExecuter(netsvc::server::IAppModule* /*mod*/)
-    : m_dbExec(new dbExecuter())
+commandExecuter::commandExecuter(netsvc::server::IAppModule* mod)
+    : m_dbExec(new dbExecuter(mod))
 {
 }
 

data/source/bzs/db/protocol/hs/hsCommandExecuter.h

@@ -188,6 +188,7 @@ class dbExecuter : public engine::mysql::dbManager
                          resultBuffer& buf, changeFunc func);
 
 public:
+    dbExecuter(netsvc::server::IAppModule* mod);
     int commandExec(std::vector<request>& requests,
                     netsvc::server::netWriter* nw);
     int errorCode(int ha_error) { return 0; };

data/source/bzs/db/protocol/tdap/client/client.h

@@ -82,6 +82,13 @@ class client
 
     std::vector<char> m_sendbuf;
 
+    bool checkVersion(int major, int ninor)
+    {
+        const clsrv_ver* v = ver();
+        if (!v) return false;
+        return (v->srvMajor > major) || ((v->srvMajor == major) && (v->srvMinor >= ninor));
+    }
+
     bool checkVersion(clsrv_ver& ver)
     {
         if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 3)))
@@ -231,11 +238,7 @@ public:
     inline bool isSupportFunction(short op)
     {
         if (op == TD_GET_SCHEMA)
-        {
-            const clsrv_ver* v = ver();
-            if (!v) return false;
-            return (v->srvMajor > 2) || ((v->srvMajor == 2) && (v->srvMinor >= 6));
-        }
+            return checkVersion(2, 6);
         return false;
     }
 
@@ -366,8 +369,12 @@ public:
             else if ((m_req.keyNum == CR_SUBOP_BY_SQL) || 
                     (m_req.keyNum == CR_SUBOP_BY_SQL_NOCKECK)) // make by sql
             {
-                m_sql = (char*)m_req.data;
                 m_req.keyNum -= 4; // -1= exists check 0 = no exists check
+                if (charsetIndexServer != CHARSET_UTF8 && charsetIndexServer != CHARSET_UTF8B4)
+                    m_sql = sqlBuilder::convertString(mysql::codePage(charsetIndexServer), 65001,
+                          (const char*)m_req.data);
+                else
+                    m_sql = (const char*)m_req.data;
             }
             else
                 m_sql = sqlBuilder::sqlCreateTable(name.c_str(), (fileSpec*)m_req.data,
@@ -420,7 +427,13 @@ public:
 
     inline void cmdConnect()
     {
-        if ((m_req.keyNum == LG_SUBOP_CONNECT) ||
+        if(m_req.keyNum == LG_SUBOP_ASSOCIATE)
+        {
+            clientID* cid = (clientID*)m_req.keybuf;
+            cid->con->addref();
+            setCon(cid->con);
+        }
+        else if ((m_req.keyNum == LG_SUBOP_CONNECT) ||
             (m_req.keyNum == LG_SUBOP_NEWCONNECT))
         {
             if (con())
@@ -462,7 +475,8 @@ public:
         {
             if (con())
                 con()->cleanup();
-        }
+        }else
+        	 m_preResult = STATUS_NOSUPPORT_OP;
             
         m_req.paramMask = P_MASK_KEYONLY;
     }