Advertisement
Guest User

Untitled

a guest
Apr 22nd, 2019
87
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 27.37 KB | None | 0 0
  1. package io.mycat.proxy.packet;
  2.  
  3. import io.mycat.beans.mysql.MySQLCapabilityFlags;
  4. import io.mycat.beans.mysql.MySQLServerStatus;
  5. import io.mycat.proxy.MycatExpection;
  6.  
  7. import java.io.IOException;
  8.  
  9. import static io.mycat.proxy.packet.ComQueryState.*;
  10. import static io.mycat.proxy.packet.MySQLPayloadType.*;
  11.  
  12. public interface MySQLPacketResolver extends OkPacket, LongDataPacket, EOFPacket, ErrorPacket, PreparedOKPacket, ColumnDefPacket, MySQLPacketAppendStrategy {
  13.  
  14. void setMySQLPacketCallback(MySQLPacketCallback callback);
  15.  
  16. MySQLPacketCallback getMySQLPacketCallback();
  17.  
  18. public void setPayloadLength(int length);
  19.  
  20. public int getPayloadLength();
  21.  
  22. byte setPacketId(byte packetId);
  23.  
  24. byte getPacketId();
  25.  
  26. boolean readFromChannel() throws IOException;
  27.  
  28. void writeToChannel() throws IOException;
  29.  
  30. boolean hasResolvePayloadType();
  31.  
  32. void markedResolvePayloadType(boolean marked);
  33.  
  34. int getHead();
  35.  
  36. int setHead(int head);
  37.  
  38. int setCurrentComQuerySQLType(int type);
  39.  
  40. int getCurrentSQLType();
  41.  
  42. int setStartPos(int i);
  43.  
  44. int getStartPos();
  45.  
  46. int setEndPos(int i);
  47.  
  48. int getEndPos();
  49.  
  50. ComQueryState getState();
  51.  
  52. void setState(ComQueryState state);
  53.  
  54. void setMySQLpayloadType(MySQLPayloadType type);
  55.  
  56. int setColumnCount(int count);
  57.  
  58. int getColumnCount();
  59.  
  60. boolean clientDeprecateEof();
  61.  
  62. MySQLCapabilityFlags capabilityFlags();
  63.  
  64. int setRemainsBytes(int remainsBytes);
  65.  
  66. int getRemainsBytes();
  67.  
  68. public boolean setMultiPacket(boolean c);
  69.  
  70. public boolean isMultiPacket();
  71.  
  72. public MySQLPacket currentProxybuffer();
  73.  
  74. public MySQLPacket currentPayload();
  75.  
  76. default void setRequestFininshed(boolean b) {
  77. setState(b ? FIRST_PACKET : QUERY_PACKET);
  78. }
  79.  
  80. default boolean isRequestFininshed() {
  81. return getState() != QUERY_PACKET;
  82. }
  83.  
  84. void resetCurrentPayloadMySQLPacket();
  85.  
  86. default void reset() {
  87. setMySQLPacketCallback(MySQLPacketCallback.DEFAULT);
  88. currentProxybuffer().reset();
  89. resetCurrentPayloadMySQLPacket();
  90. setPacketId((byte) -1);
  91. markedResolvePayloadType(false);
  92. setHead(0);
  93. setStartPos(0);
  94. setEndPos(0);
  95. setCurrentComQuerySQLType(0);
  96. setMySQLpayloadType(UNKNOWN);
  97. setColumnCount(0);
  98. setRemainsBytes(0);
  99. setMultiPacket(false);
  100. setColumnCatalog(null);
  101. setColumnSchema(null);
  102. setColumnOrgTable(null);
  103. setColumnName(null);
  104. setColumnOrgName(null);
  105. setColumnNextLength(0);
  106. setColumnLength(0);
  107. setColumnFlags(0);
  108. setColumnDecimals((byte) 0);
  109. setColumnDefaultValues(null);
  110. setErrorStage(0);
  111. setErrorMaxStage(0);
  112. setErrorProgress(0);
  113. setErrorProgressInfo(null);
  114. setErrorMark((byte) 0);
  115. setErrorSqlState(null);
  116. setErrorMessage(null);
  117. setLongDataParamId(0);
  118. setPreparedOkStatementId(0);
  119. setPrepareOkColumnsCount(0);
  120. setPrepareOkParametersCount(0);
  121. setPreparedOkWarningCount(0);
  122. setLongDataParamId(0);
  123. setLongData(null);
  124. setOkAffectedRows(0);
  125. setOkLastInsertId(0);
  126. setOkServerStatus(0);
  127. setOkWarningCount(0);
  128. setOkStatusInfo(null);
  129. setOkSessionStateInfoType((byte) 0);
  130. setOkSessionStateInfoTypeData(null);
  131. setOkMessage(null);
  132. setEofWarningCount(0);
  133. setEofServerStatus(0);
  134. }
  135.  
  136. default boolean readMySQLPacketFully() throws IOException {
  137. MySQLPacket mySQLPacket = currentProxybuffer();
  138. int wholePakcetSize = mySQLPacket.packetReadEndIndex() - mySQLPacket.packetReadStartIndex();
  139. if (wholePakcetSize < 4) return false;
  140. int startIndex = mySQLPacket.packetReadStartIndex();
  141. int length = (int) mySQLPacket.getFixInt(startIndex, 3);
  142. System.out.println("payloadLength:" + length);
  143. setPayloadLength(length);
  144. byte packetId = mySQLPacket.getByte(startIndex + 3);
  145. System.out.println("========full====packetId=========");
  146. setPacketId(packetId);
  147. System.out.println(packetId);
  148. System.out.println("======full======packetId=========");
  149. byte andIncrementPacketId = getAndIncrementPacketId();
  150. if (packetId != andIncrementPacketId) {
  151. throw new MycatExpection("");
  152. }
  153. boolean multiPacket = length == 0xffffff;
  154.  
  155. boolean isFirstPacket = false;
  156. boolean isEnd = !multiPacket;
  157. int packetLength = length;
  158. if (multiPacket) {
  159. packetLength = 0xffffff;
  160. } else {
  161. packetLength = packetLength + 4;
  162. }
  163. if (packetLength <= (wholePakcetSize)) {
  164. setStartPos(startIndex);
  165. setEndPos(startIndex + packetLength);
  166. if (!isMultiPacket()) {
  167. if (length > 0) {
  168. int aByte = mySQLPacket.getByte(startIndex + 4) & 0xff;
  169. System.out.println("=======full=====head=========");
  170. System.out.println(aByte);
  171. System.out.println("--------full=====head-----------------------");
  172. setHead(aByte);
  173. markedResolvePayloadType(false);
  174. isFirstPacket = true;
  175. }
  176. }
  177. setMultiPacket(multiPacket);
  178. if (isFirstPacket && isEnd) {
  179. appendFirstPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  180. } else if (!isFirstPacket && isEnd) {
  181. appendEndMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  182. } else if (isFirstPacket && !isEnd) {
  183. appendFirstMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  184. } else if (!isFirstPacket && !isEnd) {
  185. appendAfterMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  186. }
  187. if (isEnd) {
  188. resolvePayloadType(getHead(), true, true, currentPayload(), getPayloadLength());
  189. }
  190. return !multiPacket;
  191. } else {
  192. return false;
  193. }
  194. }
  195.  
  196. default byte getAndIncrementPacketId() {
  197. byte packetId = getPacketId();
  198. setPacketId((byte) (packetId + 1));
  199. return packetId;
  200. }
  201.  
  202. default byte incrementPacketIdAndGet() {
  203. byte packetId = getPacketId();
  204. return setPacketId((byte) (packetId + 1));
  205. }
  206.  
  207. default boolean readMySQLPacket() throws IOException {
  208.  
  209. MySQLPacket mySQLPacket = currentProxybuffer();
  210. boolean needWholePacket = getState().isNeedFull();
  211. if (needWholePacket) {
  212. System.out.println("readMySQLPacketFully");
  213. return readMySQLPacketFully();
  214. } else {
  215. System.out.println("readMySQLPacket");
  216. int startIndex = mySQLPacket.packetReadStartIndex();
  217. int endIndex = mySQLPacket.packetReadEndIndex();
  218. int receiveSize = endIndex - startIndex;
  219. int remains = getRemainsBytes();
  220. boolean multiPacket;
  221. boolean isFirstPacket = false;
  222. if (remains == 0) {
  223. if (receiveSize < 4) return false;
  224. int payloadLength = (int) mySQLPacket.getFixInt(startIndex, 3);
  225. if (payloadLength == 0) {
  226. setRemainsBytes(0);
  227. setPayloadLength(0);
  228. setMultiPacket(false);
  229. setStartPos(startIndex);
  230. setEndPos(startIndex + 3);
  231. return true;
  232. }
  233. int aByte = mySQLPacket.getByte(startIndex + 4) & 0xff;
  234. if (aByte == 0xfe || aByte == 0x00) {
  235. return readMySQLPacketFully();
  236. }
  237. System.out.println("payloadLength:" + payloadLength);
  238. setPayloadLength(payloadLength);
  239. multiPacket = setMultiPacket(payloadLength == 0xffffff);
  240. if (multiPacket) {
  241. payloadLength = 0xffffff;
  242. } else {
  243. payloadLength = payloadLength + 4;
  244. }
  245. markedResolvePayloadType(false);
  246. byte packetId = mySQLPacket.getByte(startIndex + 3);
  247. System.out.println("------------packetId--------------------");
  248. System.out.println(packetId);
  249. System.out.println("-----------packetId--------------------");
  250. setPacketId(packetId);
  251. byte andIncrementPacketId = getAndIncrementPacketId();
  252. if (packetId != andIncrementPacketId || packetId < 0) {
  253. throw new MycatExpection("");
  254. }
  255.  
  256. System.out.println(aByte);
  257. setHead(aByte);
  258. isFirstPacket = true;
  259. if (payloadLength < receiveSize) {
  260. setStartPos(startIndex);
  261. setEndPos(startIndex + payloadLength);
  262. remains = 0;
  263. } else {
  264. remains = payloadLength - receiveSize;
  265. setStartPos(startIndex);
  266. setEndPos(startIndex + receiveSize);
  267. }
  268. } else {
  269. if (receiveSize >= remains) {
  270. setStartPos(startIndex);
  271. setEndPos(startIndex + remains);
  272. remains = 0;
  273. } else {
  274. remains -= receiveSize;
  275. setStartPos(startIndex);
  276. setEndPos(startIndex + receiveSize);
  277. }
  278. multiPacket = isMultiPacket();
  279. }
  280. setRemainsBytes(remains);
  281. boolean isEnd = !multiPacket;
  282. if (isFirstPacket && isEnd) {
  283. appendFirstPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  284. } else if (!isFirstPacket && isEnd) {
  285. appendEndMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  286. } else if (isFirstPacket && !isEnd) {
  287. appendFirstMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  288. } else if (!isFirstPacket && !isEnd) {
  289. appendAfterMultiPacket(currentPayload(), mySQLPacket, getStartPos(), getEndPos(), getRemainsBytes());
  290. }
  291. if (isEnd) {
  292. resolvePayloadType(getHead(), false, true, currentPayload(), getPayloadLength());
  293. }
  294. return true;
  295. }
  296. }
  297.  
  298. default public void resolvePayloadType(int head, boolean isPacketFinished, boolean parse, MySQLPacket mySQLPacket, int wholePacketLength) {
  299. MySQLPacketCallback callback = getMySQLPacketCallback();
  300. if (hasResolvePayloadType()) {
  301. return;
  302. } else {
  303. markedResolvePayloadType(true);
  304. }
  305. switch (getState()) {
  306. case QUERY_PACKET: {
  307. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  308. if (head == 18) {
  309. int statementId = (int) mySQLPacket.readFixInt(4);
  310. setLongDataStatementId(statementId);
  311. int paramId = (int) mySQLPacket.readFixInt(2);
  312. setLongDataParamId(paramId);
  313. setLongData(mySQLPacket.getEOFStringBytes(mySQLPacket.packetReadStartIndex()));
  314. setMySQLpayloadType(MySQLPayloadType.SEND_LONG_DATA);
  315. setState(QUERY_PACKET);
  316. setRequestFininshed(true);
  317. callback.onRequest(mySQLPacket, getStartPos(), getEndPos());
  318. return;
  319. } else if (head == 25) {
  320. setMySQLpayloadType(MySQLPayloadType.COM_STMT_CLOSE);
  321. setState(QUERY_PACKET);
  322. setRequestFininshed(true);
  323. callback.onRequest(mySQLPacket, getStartPos(), getEndPos());
  324. return;
  325. } else {
  326. setMySQLpayloadType(MySQLPayloadType.UNKNOWN);
  327. setCurrentComQuerySQLType(head);
  328. setState(FIRST_PACKET);
  329. setRequestFininshed(true);
  330. }
  331. callback.onRequest(mySQLPacket, getStartPos(), getEndPos());
  332. return;
  333. }
  334. case FIRST_PACKET: {
  335. if (!isPacketFinished) throw new MycatExpection("unknown state!");
  336. if (head == 0xff) {
  337. setMySQLpayloadType(MySQLPayloadType.ERROR);
  338. setState(ComQueryState.COMMAND_END);
  339. callback.onError(mySQLPacket, getStartPos(), getEndPos());
  340. callback.onRowFinished();
  341. } else if (head == 0x00) {
  342. if (getCurrentSQLType() == 22 && wholePacketLength == 16 && getPacketId() == 1) {
  343. resolvePrepareOkPacket(mySQLPacket, isPacketFinished);
  344. callback.onPrepareOk(mySQLPacket, getStartPos(), getEndPos());
  345. return;
  346. } else {
  347. setMySQLpayloadType(MySQLPayloadType.OK);
  348. setOkServerStatus(okPacketReadServerStatus(mySQLPacket));
  349. callback.onOk(mySQLPacket, getStartPos(), getEndPos());
  350. if (hasMoreResult(getOkServerStatus())) {
  351. setState(FIRST_PACKET);
  352. } else {
  353. setState(ComQueryState.COMMAND_END);
  354. callback.onRowFinished();
  355. }
  356. return;
  357. }
  358. } else if (head == 0xfb) {
  359. setState(ComQueryState.LOCAL_INFILE_FILE_CONTENT);
  360. setMySQLpayloadType(LOCAL_INFILE_REQUEST);
  361. return;
  362. } else if (head == 0xfe) {
  363. setMySQLpayloadType(EOF);
  364. setOkServerStatus(eofPacketReadStatus(mySQLPacket));
  365. setState(ComQueryState.COMMAND_END);
  366. callback.onEof(mySQLPacket, getStartPos(), getEndPos());
  367. return;
  368. } else {
  369. setColumnCount((int) mySQLPacket.getLenencInt(getStartPos() + MySQLPacket.getPacketHeaderSize()));
  370. setMySQLpayloadType(MySQLPayloadType.COLUMN_COUNT);
  371. setState(ComQueryState.COLUMN_DEFINITION);
  372. callback.onColumnCount(mySQLPacket, getStartPos(), getEndPos());
  373. }
  374. return;
  375. }
  376. case COLUMN_DEFINITION: {
  377. if (setColumnCount(getColumnCount() - 1) == 0) {
  378. setState(!clientDeprecateEof() ? ComQueryState.COLUMN_END_EOF : ComQueryState.RESULTSET_ROW);
  379. }
  380. setMySQLpayloadType(MySQLPayloadType.COLUMN_DEFINITION);
  381. callback.onColumnDef(mySQLPacket, getStartPos(), getEndPos());
  382. return;
  383. }
  384. case COLUMN_END_EOF: {
  385. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  386. setOkServerStatus(eofPacketReadStatus(mySQLPacket));
  387. setMySQLpayloadType(EOF);
  388. setState(ComQueryState.RESULTSET_ROW);
  389. callback.onColumnDefEof(mySQLPacket, getStartPos(), getEndPos());
  390. return;
  391. }
  392. case RESULTSET_ROW: {
  393. if (head == 0x00) {
  394. setMySQLpayloadType(MySQLPayloadType.BINARY_RESULTSET_ROW);
  395. callback.onBinaryRow(mySQLPacket, getStartPos(), getEndPos());
  396. } else if (head == 0xfe && wholePacketLength < 0xffffff) {
  397. resolveResultsetRowEnd(mySQLPacket, isPacketFinished);
  398. } else if (head == 0xff) {
  399. setMySQLpayloadType(MySQLPayloadType.ERROR);
  400. setState(ComQueryState.COMMAND_END);
  401. callback.onRowError(mySQLPacket, getStartPos(), getEndPos());
  402. callback.onRowFinished();
  403. } else {
  404. setMySQLpayloadType(MySQLPayloadType.TEXT_RESULTSET_ROW);
  405. //text resultset row
  406. callback.onTextRow(mySQLPacket, getStartPos(), getEndPos());
  407. }
  408. break;
  409. }
  410. // case RESULTSET_ROW_END:
  411. // resolveResultsetRowEnd(mySQLPacket, isPacketFinished);
  412. // break;
  413. case PREPARE_FIELD:
  414. case PREPARE_FIELD_EOF:
  415. case PREPARE_PARAM:
  416. case PREPARE_PARAM_EOF:
  417. resolvePrepareResponse(mySQLPacket, head, isPacketFinished);
  418. return;
  419. case LOCAL_INFILE_FILE_CONTENT:
  420. if (wholePacketLength == 4) {
  421. setState(ComQueryState.LOCAL_INFILE_OK_PACKET);
  422. setMySQLpayloadType(LOCAL_INFILE_EMPTY_PACKET);
  423. return;
  424. } else {
  425. setState(ComQueryState.LOCAL_INFILE_FILE_CONTENT);
  426. setMySQLpayloadType(LOCAL_INFILE_CONTENT_OF_FILENAME);
  427. return;
  428. }
  429. case LOCAL_INFILE_OK_PACKET:
  430. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  431. setMySQLpayloadType(MySQLPayloadType.OK);
  432. setOkServerStatus(okPacketReadServerStatus(mySQLPacket));
  433. setState(ComQueryState.COMMAND_END);
  434. return;
  435. case COMMAND_END: {
  436. System.out.println("--------------");
  437. }
  438. return;
  439. default: {
  440. if (!isPacketFinished) {
  441. throw new RuntimeException("unknown state!");
  442. } else {
  443.  
  444. }
  445. }
  446. }
  447. }
  448.  
  449. default public void setResponseFinished(boolean b) {
  450. setState(b ? ComQueryState.COMMAND_END : FIRST_PACKET);
  451. }
  452.  
  453. default public boolean isResponseFinished() {
  454. return getState() == ComQueryState.COMMAND_END;
  455. }
  456.  
  457. default public int eofPacketReadStatus(MySQLPacket buffer) {
  458. int bpStartIndex = buffer.packetReadStartIndex();
  459. int bpEndIndex = buffer.packetReadEndIndex();
  460. buffer.packetReadStartIndex(getStartPos());
  461. buffer.packetReadStartIndex(getEndPos());
  462. //7 = packetLength(3) + packetId(1) + pkgType(1) + warningCount(2)
  463. // buffers.skipInReading(7);
  464. int i = setOkServerStatus((int) buffer.getFixInt(7, 2));//status
  465. buffer.packetReadStartIndex(bpStartIndex);
  466. buffer.packetReadEndIndex(bpEndIndex);
  467. return i;
  468. }
  469.  
  470. default public int okPacketReadServerStatus(MySQLPacket buffer) {
  471. int bpStartIndex = buffer.packetReadStartIndex();
  472. int bpEndIndex = buffer.packetReadEndIndex();
  473. buffer.packetReadStartIndex(getStartPos() + 4);
  474. buffer.packetReadEndIndex(getEndPos());
  475. byte header = buffer.readByte();
  476. assert (0x00 == header) || (0xfe == header);
  477. int serverStatus = 0;
  478.  
  479. setOkAffectedRows(buffer.readLenencInt());//affectedRows
  480. setOkLastInsertId(buffer.readLenencInt());//lastInsertId
  481. MySQLCapabilityFlags capabilityFlags = capabilityFlags();
  482. if (capabilityFlags.isClientProtocol41() || capabilityFlags.isKnowsAboutTransactions()) {
  483. setOkServerStatus(serverStatus = (int) buffer.readFixInt(2));
  484. buffer.packetReadStartIndex(bpStartIndex);
  485. buffer.packetReadEndIndex(bpEndIndex);
  486. return serverStatus;
  487. }
  488. throw new java.lang.RuntimeException("OKPacket readServerStatus error ");
  489. }
  490. //
  491. // default public void okPacketReadPayload(MySQLPacket buffers) {
  492. // byte header = buffers.readByte();
  493. // assert (0x00 == header) || (0xfe == header);
  494. // setOkAffectedRows(buffers.readLenencInt());
  495. // setOkLastInsertId(buffers.readLenencInt());
  496. //
  497. // MySQLCapabilityFlags capabilityFlags = capabilityFlags();
  498. // if (capabilityFlags.isClientProtocol41()) {
  499. // setOkServerStatus((int) buffers.readFixInt(2));
  500. // setOkWarningCount((int) buffers.readFixInt(2));
  501. //
  502. // } else if (capabilityFlags.isKnowsAboutTransactions()) {
  503. // setOkServerStatus((int) buffers.readFixInt(2));
  504. // }
  505. // if (capabilityFlags.isSessionVariableTracking()) {
  506. // setOkStatusInfo(buffers.readLenencBytes());
  507. // if ((getOkServerStatus() & MySQLServerStatus.STATE_CHANGED) != 0) {
  508. // setOkSessionStateInfoType(buffers.readByte());
  509. // setOkSessionStateInfoTypeData(buffers.readLenencBytes());
  510. // }
  511. // } else {
  512. // setOkMessage(buffers.readEOFStringBytes());
  513. // }
  514. // }
  515.  
  516. default void resolveResultsetRowEnd(MySQLPacket mySQLPacket, boolean isPacketFinished) {
  517. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  518. if (clientDeprecateEof()) {
  519. setMySQLpayloadType(MySQLPayloadType.OK);
  520. setOkServerStatus(okPacketReadServerStatus(mySQLPacket));
  521. getMySQLPacketCallback().onRowOk(mySQLPacket, getStartPos(), getEndPos());
  522. } else {
  523. setMySQLpayloadType(EOF);
  524. setOkServerStatus(eofPacketReadStatus(mySQLPacket));
  525. getMySQLPacketCallback().onRowEof(mySQLPacket, getStartPos(), getEndPos());
  526. }
  527. if (hasMoreResult(getOkServerStatus())) {
  528. setState(FIRST_PACKET);
  529. } else {
  530. setState(ComQueryState.COMMAND_END);
  531. getMySQLPacketCallback().onRowFinished();
  532. }
  533. }
  534.  
  535. default void resolvePrepareOkPacket(MySQLPacket buffer, boolean isPacketFinished) {
  536. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  537. int bpStartIndex = buffer.packetReadStartIndex();
  538. int bpEndIndex = buffer.packetReadEndIndex();
  539. buffer.packetReadStartIndex(getStartPos() + 4);
  540. buffer.packetReadStartIndex(getEndPos());
  541.  
  542. setErrorStage(buffer.readByte());
  543. setLongDataStatementId(buffer.readFixInt(4));
  544. setPrepareOkColumnsCount((int) buffer.readFixInt(2));
  545. setPrepareOkParametersCount((int) buffer.readFixInt(2));
  546. setMySQLpayloadType(MySQLPayloadType.PREPARE_OK);
  547. buffer.packetReadStartIndex(bpStartIndex);
  548. buffer.packetReadEndIndex(bpEndIndex);
  549. if (this.getPrepareOkColumnsCount() == 0 && getPrepareOkParametersCount() == 0) {
  550. setState(ComQueryState.COMMAND_END);
  551. return;
  552. } else if (this.getPrepareOkColumnsCount() > 0) {
  553. setState(ComQueryState.PREPARE_FIELD);
  554. return;
  555. }
  556. if (getPrepareOkParametersCount() > 0) {
  557. setState(ComQueryState.PREPARE_PARAM);
  558. return;
  559. }
  560. throw new RuntimeException("unknown state!");
  561. }
  562.  
  563. public default void columnDefPacketReadPayload(MySQLPacket buffer) {
  564. setColumnCatalog(buffer.readLenencStringBytes());
  565. setColumnSchema(buffer.readLenencStringBytes());
  566. setColumnTable(buffer.readLenencStringBytes());
  567. setColumnOrgTable(buffer.readLenencStringBytes());
  568. setColumnName(buffer.readLenencStringBytes());
  569. setColumnOrgName(buffer.readLenencStringBytes());
  570. setColumnNextLength(buffer.readByte());
  571. setColumnCharsetSet((int) buffer.readFixInt(2));
  572. setColumnLength((int) buffer.readFixInt(4));
  573. setColumnType((byte) (buffer.readByte() & 0xff));
  574. setColumnFlags((int) buffer.readFixInt(2));
  575. setColumnDecimals(buffer.readByte());
  576. if (buffer.readByte() != 0x00 && buffer.readByte() != 0x00) {//filler
  577. throw new IllegalArgumentException("ColumnDefPacket read fail!!!:" + this);
  578. }
  579. if (getCurrentSQLType() == 4) {//COM_FIELD_LIST
  580. setColumnDefaultValues(buffer.readLenencStringBytes());
  581. }
  582. }
  583.  
  584. default void resolvePrepareResponse(MySQLPacket proxyBuf, int head, boolean isPacketFinished) {
  585. if (!isPacketFinished) throw new RuntimeException("unknown state!");
  586. MySQLPacketCallback callback = getMySQLPacketCallback();
  587. PreparedOKPacket p = this;
  588. if (p.getPrepareOkColumnsCount() > 0 && (getState() == ComQueryState.PREPARE_FIELD)) {
  589. p.setPrepareOkColumnsCount(p.getPrepareOkColumnsCount() - 1);
  590. setMySQLpayloadType(MySQLPayloadType.COLUMN_DEFINITION);
  591. setState(ComQueryState.PREPARE_FIELD);
  592. callback.onPrepareOkColumnDef(proxyBuf, getStartPos(), getEndPos());
  593. if (p.getPrepareOkColumnsCount() == 0) {
  594. if (!clientDeprecateEof()) {
  595. setState(ComQueryState.PREPARE_FIELD_EOF);
  596. } else if (p.getPrepareOkParametersCount() > 0) {
  597. setState(ComQueryState.PREPARE_PARAM);
  598. } else {
  599. setState(ComQueryState.COMMAND_END);
  600. }
  601. }
  602. return;
  603. } else if (getState() == ComQueryState.PREPARE_FIELD_EOF && head == 0xFE) {
  604. setOkServerStatus(eofPacketReadStatus(proxyBuf));
  605. setMySQLpayloadType(EOF);
  606. setState(ComQueryState.PREPARE_PARAM);
  607. callback.onPrepareOkColumnDefEof(proxyBuf, getStartPos(), getEndPos());
  608. return;
  609. } else if (p.getPrepareOkParametersCount() > 0 && getState() == ComQueryState.PREPARE_PARAM) {
  610. p.setPrepareOkParametersCount(p.getPrepareOkParametersCount() - 1);
  611. setMySQLpayloadType(MySQLPayloadType.COLUMN_DEFINITION);
  612. setState(ComQueryState.PREPARE_PARAM);
  613. callback.onPrepareOkParameterDef(proxyBuf, getStartPos(), getEndPos());
  614. if (p.getPrepareOkParametersCount() == 0) {
  615. if (!clientDeprecateEof()) {
  616. setState(ComQueryState.PREPARE_PARAM_EOF);
  617. return;
  618. } else {
  619. setState(ComQueryState.COMMAND_END);
  620. return;
  621. }
  622. } else {
  623. return;
  624. }
  625. } else if (p.getPrepareOkColumnsCount() == 0 && p.getPrepareOkParametersCount() == 0 && !clientDeprecateEof() && ComQueryState.PREPARE_PARAM_EOF == getState() && head == 0xFE) {
  626. setOkServerStatus(eofPacketReadStatus(proxyBuf));
  627. setMySQLpayloadType(EOF);
  628. setState(ComQueryState.COMMAND_END);
  629. callback.onPrepareOkParameterDefEof(proxyBuf, getStartPos(), getEndPos());
  630. return;
  631. }
  632. throw new RuntimeException("unknown state!");
  633. }
  634.  
  635. public static boolean hasMulitQuery(int serverStatus) {
  636. return MySQLServerStatus.statusCheck(serverStatus, MySQLServerStatus.MULIT_QUERY);
  637. }
  638.  
  639. public static boolean hasMoreResult(int serverStatus) {
  640. return MySQLServerStatus.statusCheck(serverStatus, MySQLServerStatus.MORE_RESULTS);
  641. }
  642.  
  643. public static boolean hasResult(int serverStatus) {
  644. return (hasMoreResult(serverStatus) || hasMulitQuery(serverStatus));
  645. }
  646.  
  647. public static boolean hasFatch(int serverStatus) {
  648. // 检查是否通过fatch执行的语句
  649. return MySQLServerStatus.statusCheck(serverStatus, MySQLServerStatus.CURSOR_EXISTS);
  650. }
  651.  
  652. public static boolean hasTrans(int serverStatus) {
  653. // 检查是否通过fatch执行的语句
  654. boolean trans = MySQLServerStatus.statusCheck(serverStatus, MySQLServerStatus.IN_TRANSACTION)
  655. || MySQLServerStatus.statusCheck(serverStatus, MySQLServerStatus.IN_TRANS_READONLY);
  656. return trans;
  657. }
  658.  
  659.  
  660. MySQLPayloadType getPailoadType();
  661. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement