大约一年前，MQL5 补充了网络函数，从而可以操控套接字（sockets） 了。 这为程序员开发市场所需产品提供了巨大的机遇。 如今，他们能够实现以前需要动态库支持的功能。 在本系列的两篇文章中，我们将研究这样的示例之一。 在第一篇文章中，我将研究 MySQL 连通器原理，而在第二篇文章中，我将利用连通器开发最简单的应用系统，即收集终端里所提供信号属性的服务，和查看它们 随时间流逝而变化的程序。（参见图例 1）。
图例 1. 观察信号属性随时间变化的程序
套接字是软件实现的进程间交换数据的接口。 这些过程既可以在单台 PC 上启动，也可在连接到网络里的不同 PC 上启动。
MQL5 仅提供客户端 TCP 套接字。 这意味着我们能够发起连接，但我们不能等待并响应外部的连接请求。 所以，如果我们需要通过套接字在 MQL5 程序之间提供连通，则需要一个充当中介的服务器。 服务器等待并侦听端口的连接，并响应客户端的请求执行某些功能。 若要连接到服务器，我们需要知道其 IP 地址和端口。
端口是一个介于 0 到 65535 之间的数字。 有三个端口范围：系统保留（0 - 1023），用户（1024 - 49151），和动态端口（49152 - 65535）。 一些端口已分配给某些功能占用。 分配是由 IANA 执行，该组织负责管理 IP 地址区段和顶级域名，并注册 MIME 数据类型。
默认情况下，端口 3306 已分配给 MySQL。 当访问服务器时，我们将与其连接。 请注意，此端口值可以更改。 因此，在开发 EA 时，应在输入中设置端口以及 IP 地址。
在操控套接字时，会用到以下步骤：
当操控多个连接时，请记住单个 MQL5 程序有最多同时打开 128 个套接字的限制。
流量分析器有助于调试应用套接字的程序代码。 缺了它，整个过程就像不用示波器进行电子设备维修一样。 分析器从选定的网络接口捕获数据，并以可读形式显示它们。 它跟踪数据包的大小，它们之间的时间间隔，重传和连接丢失是否存在，以及许多其他有用的数据。 它还解码许多协议。
出于这些目的，我个人选用 Wireshark。
图例 2. Wireshark 流量分析器
图例 2 流量分析器窗口展示，其内含有捕获的数据包：
显示过滤器不会限制数据包捕获。 从状态栏中可清晰看到，此刻正在处理内存中捕获到的 2623 个数据包中的 35 个。 为了降低 PC 的负担，我们应在选择网络接口时设置捕获过滤器，如图例 3 所示。 仅当所有其他数据包确实没有用时，才应这样做。
图例 3. 数据包捕获过滤器
为了令我们自己熟悉流量分析器，我们尝试与 “google.com” 服务器建立连接，并跟踪该过程。 为此，编写一个小脚本。
void OnStart() { //--- Get socket handle int socket=SocketCreate(); if(socket==INVALID_HANDLE) return; //--- Establish connection if(SocketConnect(socket,"google.com",80,2000)==false) { return; } Sleep(5000); //--- Close connection SocketClose(socket); }
为此，首先我们创建一个套接字，并利用 SocketCreate() 函数获取其控柄。 在这种情况下，按参考资料的说辞，您可能会得到两种情况的错误，尽管这几乎是不可能的：
得到控柄后，尝试建立连接。 在本示例中，我们连接到 “google.com” 服务器（不要忘记在终端设置中将其添加到允许的服务器地址中），即连接到端口 80，且超时为 2000 毫秒。 建立连接之后，等待 5 秒钟，然后将其关闭。 现在，我们在流量分析器窗口中看看它的样子。
图例 4. 建立和关闭连接
在图例 4 中，我们能看到脚本与 IP 地址为 “172.217.16.14” 的 “google.com” 服务器之间的数据交换。 由于过滤器行里含有 "tcp.port==80" 表达式，因此此处未显示 DNS 查询。
顶部的三个数据包代表建立连接，而底部的三个数据包代表将其关闭。 “Time（时间）” 列显示数据包之间的时间，我们可以看到 5 秒钟的停顿时间。 请注意，数据包的颜色为绿色，与图例 2 中的不同。 这是因为在之前的情况下，分析器在数据交换中检测到 MySQL 协议。 在当前情况下，没有数据经过，分析器使用默认的 TCP 颜色显示数据包。
根据协议，MySQL 服务器应在建立连接后发送应答语。 作为响应，客户端发送授权请求。 在 dev.mysql.com 网站上，该机制于连接阶段部分进行了详细阐述。 如果未收到服务端的应答语，则 IP 地址无效，或服务器正在侦听其它端口。 无论何种情况，这意味着我们已连接的绝对不是 MySQL 服务器。 在正常状况下，我们需要接收数据（从套接字读取数据），并解析它。
在 CMySQLTransaction类中（稍后将详细讲述），数据接收已如下实现：
//+------------------------------------------------------------------+ //| Data receipt | //+------------------------------------------------------------------+ bool CMySQLTransaction::ReceiveData(ushort error_code=0) { char buf[]; uint timeout_check=GetTickCount()+m_timeout; do { //--- Get the amount of data that can be read from the socket uint len=SocketIsReadable(m_socket); if(len) { //--- Read data from the socket to the buffer int rsp_len=SocketRead(m_socket,buf,len,m_timeout); m_rx_counter+= rsp_len; //--- Send the buffer for handling ENUM_TRANSACTION_STATE res = Incoming(buf,rsp_len); //--- Get the result the following actions will depend on if(res==MYSQL_TRANSACTION_COMPLETE) // server response fully accepted return true; // exit (successful) else if(res==MYSQL_TRANSACTION_ERROR) // error { if(m_packet.error.code) SetUserError(MYSQL_ERR_SERVER_ERROR); else SetUserError(MYSQL_ERR_INTERNAL_ERROR); return false; // exit (error) } //--- In case of another result, continue waiting for data in the loop } } while(GetTickCount()<timeout_check && !IsStopped()); //--- If waiting for the completion of the server response receipt took longer than m_timeout, //--- exit with the error SetUserError(error_code); return false; }此处的 m_socket 是早前创建的套接字控柄，而 m_timeout 是读取数据的超时，可作为 SocketRead() 函数接受 数据片的参数，以及整体形式接收数据的超时。 进入循环之前，设置时间戳。 若达到它所认定的数据接收超时：
uint timeout_check=GetTickCount()+m_timeout;
接下来，在循环中读取 SocketIsReadable() 函数结果，并一直等到其返回非零值。 之后，将数据读取到缓冲区，并传递给处理过程。
uint len=SocketIsReadable(m_socket); if(len) { //--- Read data from the socket to the buffer int rsp_len=SocketRead(m_socket,buf,len,m_timeout); m_rx_counter+= rsp_len; //--- Send the buffer for handling ENUM_TRANSACTION_STATE res = Incoming(buf,rsp_len); ... }
如果套接字中有数据，我们不要指望一次性收到整个数据包的能力。 在大多情况下，数据可能只有一小部分到达。 例如，4G 调制解调器的连接也许很差，并且会有大量重传。 故此，我们的处理程序应该能够将数据收集到一些不可分割的分组中，之后再处理它们。 我们为此使用 MySQL 数据包。
CMySQLTransaction::Incoming() 方法汇集并处理数据：
//--- Handle received data ENUM_TRANSACTION_STATE Incoming(uchar &data[], uint len);
它返回的结果令我们知道下一步该怎么做 — 继续，完成或中断接收数据的过程：
enum ENUM_TRANSACTION_STATE { MYSQL_TRANSACTION_ERROR=-1, // Error MYSQL_TRANSACTION_IN_PROGRESS=0, // In progress MYSQL_TRANSACTION_COMPLETE, // Fully completed MYSQL_TRANSACTION_SUBQUERY_COMPLETE // Partially completed };
如果发生内部错误，以及出现服务器错误，或完成数据接收时，应停止从套接字读取数据。 在所有其他情况下，则应继续。 MYSQL_TRANSACTION_SUBQUERY_COMPLETE 值表示服务器已接受并响应来自客户端多的个查询之一。 它等效于 MYSQL_TRANSACTION_IN_PROGRESS 读取算法。
图例 5. MySQL 数据包
MySQL数据包格式如图例 5 所示。 前三个字节定义数据包中有用负载的大小，而下一个字节表示序列中数据包的序列号，再后跟随数据。 每次交换开始时，序列号都设置为零。 例如，应答数据包为 0，客户端授权请求 — 1，服务器响应 — 2（连接阶段结束）。 接下来，在发送客户端查询时，序列号的值应再次设置为零，并在每个服务器响应数据包中递增。 如果数据包数量超过 255，则所传递数值归零。
在流量分析器中，最简单的数据包（MySQL ping）如下所示：
图例 6. 流量分析器中的 Ping 数据包
Ping 数据包只包含一个字节的数据，其值为 14（或十六进制形式的 0x0E）。
我们研究一下 CMySQLTransaction::Incoming() 方法，该方法将数据收集到数据包中，并将其传递给处理程序。 其节略版源代码提供如下。
ENUM_TRANSACTION_STATE CMySQLTransaction::Incoming(uchar &data[], uint len) { int ptr=0; // index of the current byte in the 'data' buffer ENUM_TRANSACTION_STATE result=MYSQL_TRANSACTION_IN_PROGRESS; // result of handling accepted data while(len>0) { if(m_packet.total_length==0) { //--- If the amount of data in the packet is unknown while(m_rcv_len<4 && len>0) { m_hdr[m_rcv_len] = data[ptr]; m_rcv_len++; ptr++; len--; } //--- Received the amount of data in the packet if(m_rcv_len==4) { //--- Reset error codes etc. m_packet.Reset(); m_packet.total_length = reader.TotalLength(m_hdr); m_packet.number = m_hdr[3]; //--- Length received, reset the counter of length bytes m_rcv_len = 0; //--- Highlight the buffer of a specified size if(ArrayResize(m_packet.data,m_packet.total_length)!=m_packet.total_length) return MYSQL_TRANSACTION_ERROR; // internal error } else // if the amount of data is still not accepted return MYSQL_TRANSACTION_IN_PROGRESS; } //--- Collect packet data while(len>0 && m_rcv_len<m_packet.total_length) { m_packet.data[m_rcv_len] = data[ptr]; m_rcv_len++; ptr++; len--; } //--- Make sure the package has been collected already if(m_rcv_len<m_packet.total_length) return MYSQL_TRANSACTION_IN_PROGRESS; //--- Handle received MySQL packet //... //--- m_rcv_len = 0; m_packet.total_length = 0; } return result; }
第一步是收集数据包头 — 前 4 个字节包含序列中的数据长度和序列号。 为了汇集包头，利用 m_hdr 缓冲区和 m_rcv_len 字节计数器。 再收集到 4 个字节后，获取它们的长度，并基于它更改 m_packet.data 缓冲区。 接收到的数据包数据被复制到其中。 数据包准备好后，将其传递给处理程序。
如果收到数据包后，len 表示的所收长度仍然非零，则表明我们已收到了若干个数据包。 我们可以在单一的 Incoming() 方法调用中处理若干个完整数据包，或几个部分。
数据包类型如下：
enum ENUM_PACKET_TYPE { MYSQL_PACKET_NONE=0, // None MYSQL_PACKET_DATA, // Data MYSQL_PACKET_EOF, // End of file MYSQL_PACKET_OK, // Ok MYSQL_PACKET_GREETING, // Greeting MYSQL_PACKET_ERROR // Error };
它们当中的每一个都有自己的处理程序，该处理程序根据协议解析其序列和内容。 解析期间收到的值将分配给相应的类成员。 在当前的连通器实现中，会解析数据包中接收到的所有数据。 这似乎有些多余，因为 “Table（表格）” 和 “Original table（原始表格）” 字段的属性经常重合。 此外，某些标志的值很少用到（参见图例 7）。 不过，这些属性的可用性能够在程序的应用层灵活地构建与 MySQL 服务器的交互逻辑。
图例 7. 数据包的字段说明
发送数据于此要容易一些。
//+------------------------------------------------------------------+ //| Form and send ping | //+------------------------------------------------------------------+ bool CMySQLTransaction::ping(void) { if(reset_rbuf()==false) { SetUserError(MYSQL_ERR_INTERNAL_ERROR); return false; } //--- Prepare the output buffer m_tx_buf.Reset(); //--- Reserve a place for the packet header m_tx_buf.Add(0x00,4); //--- Place the command code m_tx_buf+=uchar(0x0E); //--- Form a header m_tx_buf.AddHeader(0); uint len = m_tx_buf.Size(); //--- Send a packet if(SocketSend(m_socket,m_tx_buf.Buf,len)!=len) return false; m_tx_counter+= len; return true; }
上面提供了 ping 发送方法的源代码。 将数据复制到准备好的缓冲区。 若执行 ping 操作，这就是 0x0E 命令的代码。 接下来，研究形成包头的数据量和数据包序列号。 对于 ping，序列号始终等于零。 之后，尝试利用 SocketSend() 函数发送封装好的数据包。
发送查询（Query）的方法类似于发送 ping：
//+------------------------------------------------------------------+ //| Form and send a query | //+------------------------------------------------------------------+ bool CMySQLTransaction::query(string s) { if(reset_rbuf()==false) { SetUserError(MYSQL_ERR_INTERNAL_ERROR); return false; } //--- Prepare the output buffer m_tx_buf.Reset(); //--- Reserve a place for the packet header m_tx_buf.Add(0x00,4); //--- Place the command code m_tx_buf+=uchar(0x03); //--- Add the query string m_tx_buf+=s; //--- Form a header m_tx_buf.AddHeader(0); uint len = m_tx_buf.Size(); //--- Send a packet if(SocketSend(m_socket,m_tx_buf.Buf,len)!=len) return false; m_tx_counter+= len; return true; }
唯一的区别在于，有用负载由 （0x03）命令码和查询字符串组成。
发送数据后总是跟随我们之前研究过的 CMySQLTransaction::ReceiveData() 接收方法。 如果没有返回错误，则认为业务成功。
现在是时候详细研究 CMySQLTransaction 类了。
//+------------------------------------------------------------------+ //| MySQL transaction class | //+------------------------------------------------------------------+ class CMySQLTransaction { private: //--- Authorization data string m_host; // MySQL server IP address uint m_port; // TCP port string m_user; // User name string m_password; // Password //--- Timeouts uint m_timeout; // timeout of waiting for TCP data (ms) uint m_timeout_conn; // timeout of establishing a server connection //--- Keep Alive uint m_keep_alive_tout; // time(ms), after which the connection is closed; the value of 0 - Keep Alive is not used uint m_ping_period; // period of sending ping (in ms) in the Keep Alive mode bool m_ping_before_query; // send 'ping' before 'query' (this is reasonable in case of large ping sending periods) //--- Network int m_socket; // socket handle ulong m_rx_counter; // counter of bytes received ulong m_tx_counter; // counter of bytes passed //--- Timestamps ulong m_dT; // last query time uint m_last_resp_timestamp; // last response time uint m_last_ping_timestamp; // last ping time //--- Server response CMySQLPacket m_packet; // accepted packet uchar m_hdr[4]; // packet header uint m_rcv_len; // counter of packet header bytes //--- Transfer buffer CData m_tx_buf; //--- Authorization request class CMySQLLoginRequest m_auth; //--- Server response buffer and its size CMySQLResponse m_rbuf[]; uint m_responses; //--- Waiting and accepting data from the socket bool ReceiveData(ushort error_code); //--- Handle received data ENUM_TRANSACTION_STATE Incoming(uchar &data[], uint len); //--- Packet handlers for each type ENUM_TRANSACTION_STATE PacketOkHandler(CMySQLPacket *p); ENUM_TRANSACTION_STATE PacketGreetingHandler(CMySQLPacket *p); ENUM_TRANSACTION_STATE PacketDataHandler(CMySQLPacket *p); ENUM_TRANSACTION_STATE PacketEOFHandler(CMySQLPacket *p); ENUM_TRANSACTION_STATE PacketErrorHandler(CMySQLPacket *p); //--- Miscellaneous bool ping(void); // send ping bool query(string s); // send a query bool reset_rbuf(void); // initialize the server response buffer uint tick_diff(uint prev_ts); // get the timestamp difference //--- Parser class CMySQLPacketReader reader; public: CMySQLTransaction(); ~CMySQLTransaction(); //--- Set connection parameters bool Config(string host,uint port,string user,string password,uint keep_alive_tout); //--- Keep Alive mode void KeepAliveTimeout(uint tout); // set timeout void PingPeriod(uint period) {m_ping_period=period;} // set ping period in seconds void PingBeforeQuery(bool st) {m_ping_before_query=st;} // enable/disable ping before a query //--- Handle timer events (relevant when using Keep Alive) void OnTimer(void); //--- Get the pointer to the class for working with authorization CMySQLLoginRequest *Handshake(void) {return &m_auth;} //--- Send a request bool Query(string q); //--- Get the number of server responses uint Responses(void) {return m_responses;} //--- Get the pointer to the server response by index CMySQLResponse *Response(uint idx); CMySQLResponse *Response(void) {return Response(0);} //--- Get the server error structure MySQLServerError GetServerError(void) {return m_packet.error;} //--- Options ulong RequestDuration(void) {return m_dT;} // get the last transaction duration ulong RxBytesTotal(void) {return m_rx_counter;} // get the number of received bytes ulong TxBytesTotal(void) {return m_tx_counter;} // get the number of passed bytes void ResetBytesCounters(void) {m_rx_counter=0; m_tx_counter=0;} // reset the counters of received and passed bytes };
我们仔细看看以下私密成员：
公开方法已在文档中详细说明。
对于应用层，业务类看起来如图例 8 所示。
图例 8. CMySQLTransaction 类的结构
其中:
没有公开方法负责建立和关闭连接。 当调用 CMySQLTransaction::Query() 方法时，这会自动完成。 当使用持续连接模式时，它将在第一次调用 CMySQLTransaction::Query() 时建立，并在定义的超时后关闭。
重要提示：在持续连接模式下，OnTimer 事件处理程序应接收 CMySQLTransaction::OnTimer() 方法的调用。 在这种情况下，计时器周期应小于 ping 和超时周期。
在调用 CMySQLTransaction::Query() 之前，应先设置连接参数，用户帐户，以及特殊的客户端参数值。
通常，与业务类的交互是根据以下原理执行的：
图例 9. 操控 CMySQLTransaction 类
我们来研究最简单的连接器应用示例。 为此，编写一个脚本，将 SELECT 查询发送到 world 测试数据库。
//--- input parameters input string inp_server = "127.0.0.1"; // MySQL server address input uint inp_port = 3306; // TCP port input string inp_login = "admin"; // Login input string inp_password = "12345"; // Password input string inp_db = "world"; // Database name //--- Connect MySQL transaction class #include <MySQL\MySQLTransaction.mqh> CMySQLTransaction mysqlt; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Configure MySQL transaction class mysqlt.Config(inp_server,inp_port,inp_login,inp_password); //--- Make a query string q = "select `Name`,`SurfaceArea` "+ "from `"+inp_db+"`.`country` "+ "where `Continent`='Oceania' "+ "order by `SurfaceArea` desc limit 10"; if(mysqlt.Query(q)==true) { if(mysqlt.Responses()!=1) return; CMySQLResponse *r = mysqlt.Response(); if(r==NULL) return; Print("Name: ","Surface Area"); uint rows = r.Rows(); for(uint i=0; i<rows; i++) { double area; if(r.Row(i).Double("SurfaceArea",area)==false) break; PrintFormat("%s: %.2f",r.Row(i)["Name"],area); } } else if(GetLastError()==(ERR_USER_ERROR_FIRST+MYSQL_ERR_SERVER_ERROR)) { // in case of a server error Print("MySQL Server Error: ",mysqlt.GetServerError().code," (",mysqlt.GetServerError().message,")"); } else { if(GetLastError()>=ERR_USER_ERROR_FIRST) Print("Transaction Error: ",EnumToString(ENUM_TRANSACTION_ERROR(GetLastError()-ERR_USER_ERROR_FIRST))); else Print("Error: ",GetLastError()); } }
假设我们的任务是获取比邻 “Oceania” 大陆值的国家/地区清单，并按国家/地区的面积从最大到最小的顺序排列，清单中最多包含 10 个数据项。 我们执行以下动作：
业务可能由以下三个原因之一而失败：
如果在输入里正确指定，则脚本操作的结果如下：
图例 10. 测试脚本操作结果
在第二部分中将探讨更复杂的应用多个查询和持续连接模式的示例。
内容
CMySQLTransaction 类方法列表
| 方法 |
动作 |
|---|---|
| Config |
设置连通参数 |
| KeepAliveTimeout |
设置以秒为单位的“保持活动”模式的超时 |
| PingPeriod |
设置以秒为单位的“保持活动”模式的 ping 周期 |
| PingBeforeQuery |
启用/禁用查询前 ping |
| OnTimer |
处理计时器事件（与“保持活动”有关） |
| Handshake |
获取指向类的指针从而处理授权 |
| Query |
发送查询 |
| Responses |
获取服务器响应数量 |
| Response |
获取指向服务器响应类的指针 |
| GetServerError |
获取服务器错误结构 |
| RequestDuration |
业务持续时间（以微秒为单位） |
| RxBytesTotal |
自程序启动以来接收的字节计数 |
| TxBytesTotal |
自程序启动以来发送的字节计数 |
| ResetBytesCounters |
重置接收和发送字节的计数器 |
以下是每种方法的简要说明。
bool Config( string host, // server name uint port, // port string user, // user name string password, // password string base, // database name uint keep_alive_tout // constant connection timeout (0 - not used) );
返回值：如果成功，则返回 true；否则返回 false（字符串类型参数中的无效符号）。
启用持续连接模式，并设置其超时。 超时值是以秒为单位的时间，从发送上一个查询起计算，该时间过后则连接被关闭。 如果重复查询超过了定义的超时值，则不会关闭连接。
void KeepAliveTimeout( uint tout // set the constant connection timeout in seconds (0 - disable) );
设置在持续连接模式下发送 “ping” 数据包的周期。 这样可以防止服务器关闭连接。 在最后一次查询或上次 ping 后的指定时间过后发送 ping。
void PingPeriod( uint period // set the ping period in seconds (for the constant connection mode) );
返回值：无。
启用在查询之前发送 “ping” 数据包。 在持续连接模式下，查询之间的间隔中，由于某种原因，连接可能会由于某种原因而关闭或中断。 在这种情况下，可以在发送查询之前发送 ping 到 MySQL服务器，从而确保连接处于活动状态。
void PingBeforeQuery( bool st // enable (true)/disable (false) ping before a query );
返回值：无。
在持续连接模式下使用。 该方法应从 OnTimer 事件处理程序中调用。 计时器周期不应超过 KeepAliveTimeout 和 PingPeriod 周期的最小值。
void OnTimer(void);
返回值：无。
获取指向授权类的指针。 建立与服务器的连接之前，可以用它来设置客户端职能和数据包最大尺寸的标志。 授权后，它接收服务器的职能版本和标志。
CMySQLLoginRequest *Handshake(void);
返回值：指向授权 CMySQLLoginRequest 类的指针。
发送查询。
bool Query( string q // query body );
返回值：执行结果； 成功 - true，错误 - false。
获取响应数量。
uint Responses(void);
返回值：服务器响应的数量。
"Ok" 或 "Data" 类型的数据包被视为响应。 如果查询成功执行，则接受一个或多个响应（对于多个查询）。
获取指向 MySQL 服务器响应类的指针
CMySQLResponse *Response( uint idx // server response index );
返回值：指向 CMySQLResponse 服务器响应类的指针。 若传递无效值作为参数，则返回 NULL。
未指定索引的重载方法等效于 Response()。
CMySQLResponse *Response(void);
返回值：指向 CMySQLResponse 服务器响应类的指针。 如果没有响应，则返回 NULL。
获取存储代码和服务器错误消息的结构。 若业务类返回 MYSQL_ERR_SERVER_ERROR 错误，则可调用它。
MySQLServerError GetServerError(void);
返回值：MySQLServerError 错误结构
获取请求执行的持续时间。
ulong RequestDuration(void);
返回值：自发送时刻到处理结束的查询持续时间（以微秒为单位）
获取接受的字节数。
ulong RxBytesTotal(void);
返回值：自程序启动以来接收的字节数（TCP 级别）。 ResetBytesCounters 方法用于重置。
获取发送的字节数。
ulong TxBytesTotal(void);
返回值：自程序启动以来传递的字节数（TCP 级别）。 ResetBytesCounters 方法用于重置。
重置已接受和已发送字节的计数器。
void ResetBytesCounters(void);
CMySQLLoginRequest 类的方法
| 方法 |
动作 |
|---|---|
| SetClientCapabilities |
设置客户端职能标志。 预定义值：0x005FA685 |
| SetMaxPacketSize |
设置最大允许的数据包大小（以字节为单位）。 预定义值: 16777215 |
| SetCharset |
定义用到的字符集。 预定义值: 8 |
| Version |
返回 MySQL 服务器版本。 例如: "5.7.21-log". |
| ThreadId |
返回当前的连接线程 ID。 它对应于 CONNECTION_ID 值。 |
| ServerCapabilities |
获取服务器职能的标志 |
| ServerLanguage |
返回编码和数据库表述 ID |
“Ok” 或 “Data” 类型的数据包被视为服务器响应。 考虑到它们之间的显著差异，该类有一套单独的方法来处理每种类型的数据包。
General CMySQLResponse 类的方法:
| 方法 |
返回值 |
|---|---|
| 类型 |
服务器响应类型: MYSQL_RESPONSE_DATA 或 MYSQL_RESPONSE_OK |
“Data” 类型数据包方法:
| 方法 |
返回值 |
|---|---|
| Fields |
字段数量 |
| Field |
按索引指向 field 类的指针（重载方法 - 按名称获取字段索引） |
| Field | 按名称的字段索引 |
| Rows |
服务器响应中的数据行数量 |
| Row |
按索引指向数据行类的指针 |
| Value |
按数据行和字段索引的字符串值 |
| Value | 按数据行和字段名称的字符串值 |
| ColumnToArray | 将数据列读取到 string 型数组的结果 |
| ColumnToArray |
将数据列读取到 int 型数组的结果，并经类型验证 |
| ColumnToArray |
将数据列读取到 long 型数组的结果，并经类型验证 |
| ColumnToArray |
将数据列读取到 double 型数组的结果，并经类型验证 |
| 方法 |
返回值 |
|---|---|
| AffectedRows |
由上次操作影响的数据行数量 |
| LastId |
LAST_INSERT_ID 值 |
| ServerStatus |
服务器状态 标志 |
| Warnings |
警告次数 |
| Message |
服务器文本消息 |
MySQLServerError 结构元素
| 元素 |
类型 |
目的 |
|---|---|---|
| code |
ushort | 错误代码 |
| sqlstate |
uint | 状态 |
| message | string | 服务器文本消息 |
CMySQLField 类的方法
| 方法 |
返回值 |
|---|---|
| Catalog |
数据表所属目录的名称 |
| Database |
数据表所属数据库的名称 |
| Table |
字段所属数据表的别名 |
| OriginalTable |
字段所属数据表的原名称 |
| Name |
字段别名 |
| OriginalName |
原字段名称 |
| Charset |
实施的编码代号 |
| Length |
数值长度 |
| 类型 |
数值类型 |
| Flags |
定义值属性的标志 |
| Decimals |
允许的小数位 |
| MQLType |
字段类型为 ENUM_DATABASE_FIELD_TYPE 值的形式（DATABASE_FIELD_TYPE_NULL 除外） |
CMySQLRow 类的方法
| 方法 |
动作 |
|---|---|
| Value |
按编号返回字段值的字符串形式 |
| operator[] |
按名称返回字段值的字符串 |
| MQLType |
按编号返回字段类型为 ENUM_DATABASE_FIELD_TYPE 值 |
| MQLType |
按名称返回字段类型为 ENUM_DATABASE_FIELD_TYPE 值 |
| Text |
按编号返回经类型验证的字段值的字符串 |
| Text |
按名称返回经类型验证的字段值的字符串 |
| Integer |
按字段编号返回经类型验证的 int 型数值 |
| Integer |
按字段名称返回经类型验证的 int 型数值 |
| Long |
按字段编号返回经类型验证的 long 型数值 |
| Long |
按字段名称返回经类型验证的 long 型数值 |
| Double |
按字段编号返回经类型验证的 double 型数值 |
| Double |
按字段名称返回经类型验证的 double 型数值 |
| Blob |
按字段编号返回经类型验证的 uchar 数组 形式的数值 |
| Blob |
按字段名称返回经类型验证的 uchar 数组 形式的数值 |
请注意： 类型验证意味着处理 int 类型的方法的可读字段应等于 DATABASE_FIELD_TYPE_INTEGER。 如果不匹配，则不会收到任何值，且该方法将返回 “false”。 将 MySQL 字段类型 ID 转换为 ENUM_DATABASE_FIELD_TYPE 类型值是在 CMySQLField::MQLType() 方法中实现的，其源代码如下所供。
//+------------------------------------------------------------------+ //| Return the field type as the ENUM_DATABASE_FIELD_TYPE value | //+------------------------------------------------------------------+ ENUM_DATABASE_FIELD_TYPE CMySQLField::MQLType(void) { switch(m_type) { case 0x00: // decimal case 0x04: // float case 0x05: // double case 0xf6: // newdecimal return DATABASE_FIELD_TYPE_FLOAT; case 0x01: // tiny case 0x02: // short case 0x03: // long case 0x08: // longlong case 0x09: // int24 case 0x10: // bit case 0x07: // timestamp case 0x0c: // datetime return DATABASE_FIELD_TYPE_INTEGER; case 0x0f: // varchar case 0xfd: // varstring case 0xfe: // string return DATABASE_FIELD_TYPE_TEXT; case 0xfb: // blob return DATABASE_FIELD_TYPE_BLOB; default: return DATABASE_FIELD_TYPE_INVALID; } }
在本文中，我们以 MySQL 连通器的实现为例，探讨了利用函数操控套接字的实验。 这已成为一条理论。 本文的第二部分会更加实用：我们将开发一个收集信号属性的服务，和一个查看其变化的程序。
随附的存档包含以下文件：
本社区仅针对特定人员开放
查看需注册登录并通过风险意识测评
5秒后跳转登录页面...
移动端课程
