MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only be done i...

25-05-01 1

在本文中，我们将为您详细介绍MYSQLStatementviolatesGTIDconsistency:Updatestonon-transactionaltablescanonlybedonei..

在本文中，我们将为您详细介绍MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only be done i...的相关知识，此外，我们还会提供一些关于13.3.5 LOCK TABLES and UNLOCK TABLES Statements(mysql 5.7)-内容来自官方文档、@types/tabulator-tables 打破 tabulator-tables 导入、a label can only be part of statement and a declaratioin is not a statement、Apache FileUpload的两种上传方式介绍及应用 --> upload file done! --> upload file done!的有用信息。

本文目录一览：

MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only be done i...
13.3.5 LOCK TABLES and UNLOCK TABLES Statements(mysql 5.7)-内容来自官方文档
@types/tabulator-tables 打破 tabulator-tables 导入
a label can only be part of statement and a declaratioin is not a statement
Apache FileUpload的两种上传方式介绍及应用 --> upload file done! --> upload file done!

MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only be done i...

[2019-04-21 10:17:20] [ERROR] [org.hibernate.engine.jdbc.spi.SqlExceptionHelper:144] Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.

org.springframework.orm.hibernate4.HibernateJdbcException: JDBC exception on Hibernate data access: SQLException for SQL [n/a]; SQL state [HY000]; error code [1785]; Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.; nested exception is org.hibernate.exception.GenericJDBCException: Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.
at org.springframework.orm.hibernate4.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:168)
at org.springframework.orm.hibernate4.HibernateTransactionManager.convertHibernateAccessException(HibernateTransactionManager.java:685)
at org.springframework.orm.hibernate4.HibernateTransactionManager.doCommit(HibernateTransactionManager.java:567)
at org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:757)
at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:726)
at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:478)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:272)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:95)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:207)
at com.sun.proxy.$Proxy3580.doUpdate(Unknown Source)
at com.jeecg.crm.controller.LeadController.doUpdate(LeadController.java:1146)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:221)
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:137)
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:747)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:676)
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:938)
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:870)
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:961)
at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:863)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:837)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at com.alibaba.druid.support.http.WebStatFilter.doFilter(WebStatFilter.java:123)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.jeecgframework.core.aop.GZipFilter.doFilter(GZipFilter.java:114)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.springframework.orm.hibernate4.support.OpenSessionInViewFilter.doFilterInternal(OpenSessionInViewFilter.java:150)
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:219)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:110)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:494)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:169)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:104)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:1025)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:445)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1137)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:637)
at org.apache.tomcat.util.net.AprEndpoint$SocketWithOptionsProcessor.run(AprEndpoint.java:2511)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
at java.lang.Thread.run(Thread.java:748)
Caused by: org.hibernate.exception.GenericJDBCException: Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.
at org.hibernate.exception.internal.StandardSQLExceptionConverter.convert(StandardSQLExceptionConverter.java:54)
at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:125)
at org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:110)
at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:129)
at org.hibernate.engine.jdbc.internal.proxy.AbstractProxyHandler.invoke(AbstractProxyHandler.java:81)
at com.sun.proxy.$Proxy3599.executeUpdate(Unknown Source)
at org.hibernate.engine.jdbc.batch.internal.NonBatchingBatch.addToBatch(NonBatchingBatch.java:56)
at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2856)
at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:3297)
at org.hibernate.action.internal.EntityInsertAction.execute(EntityInsertAction.java:88)
at org.hibernate.engine.spi.ActionQueue.execute(ActionQueue.java:362)
at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:354)
at org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:275)
at org.hibernate.event.internal.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:326)
at org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:52)
at org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1127)
at org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:325)
at org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.beforeTransactionCommit(JdbcTransaction.java:101)
at org.hibernate.engine.transaction.spi.AbstractTransactionImpl.commit(AbstractTransactionImpl.java:175)
at org.springframework.orm.hibernate4.HibernateTransactionManager.doCommit(HibernateTransactionManager.java:559)
... 60 more
Caused by: java.sql.SQLException: Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1078)
at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:4237)
at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:4169)
at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2617)
at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2778)
at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2825)
at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2156)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2459)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2376)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2360)
at com.alibaba.druid.filter.FilterChainImpl.preparedStatement_executeUpdate(FilterChainImpl.java:2843)
at com.alibaba.druid.filter.FilterAdapter.preparedStatement_executeUpdate(FilterAdapter.java:1091)
at com.alibaba.druid.filter.FilterEventAdapter.preparedStatement_executeUpdate(FilterEventAdapter.java:491)
at com.alibaba.druid.filter.FilterChainImpl.preparedStatement_executeUpdate(FilterChainImpl.java:2841)
at com.alibaba.druid.proxy.jdbc.PreparedStatementProxyImpl.executeUpdate(PreparedStatementProxyImpl.java:194)
at com.alibaba.druid.pool.DruidPooledPreparedStatement.executeUpdate(DruidPooledPreparedStatement.java:256)
at sun.reflect.GeneratedMethodAccessor29420.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:122)
... 76 more

Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables. org.springframework.orm.hibernate4.HibernateJdbcException - 国际版 Bing
https://cn.bing.com/search?FORM=U227DF&PC=U227&q=Statement+violates+GTID+consistency%3A+Updates+to+non-transactional+tables+can+only+be+done+in+either+autocommitted+statements+or+single-statement+transactions%2C+and+never+in+the+same+statement+as+updates+to+transactional+tables.+org.springframework.orm.hibernate4.HibernateJdbcException

mysql_56_GTID_in_a_nutshell.pdf
https://www.percona.com/sites/default/files/presentations/mysql_56_GTID_in_a_nutshell.pdf

mysql - Should I turn off GTID to fix this error? - Database Administrators Stack Exchange
https://dba.stackexchange.com/questions/189281/should-i-turn-off-gtid-to-fix-this-error/189437

Statement violates GTID consistency · Issue #172 · etianen/django-watson
https://github.com/etianen/django-watson/issues/172

spring batch 3.0.3 get "updates to tables using non-transactional storage engines such as MyISAM " with mysql 5.6 - Stack Overflow
https://stackoverflow.com/questions/29622004/spring-batch-3-0-3-get-updates-to-tables-using-non-transactional-storage-engine

replication - How to troubleshoot, find and fix query Percona 5.6 with error "SQLSTATE[HY000]: General error: 1785 When @@GLOBAL.ENFORCE_GTID_CONSISTENCY = 1" - Database Administrators Stack Exchange
https://dba.stackexchange.com/questions/102258/how-to-troubleshoot-find-and-fix-query-percona-5-6-with-error-sqlstatehy000

Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.; nested exception is org.hibernate.exception.GenericJDBCException: Statement violates GTID consistency: Updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables

mysql 使用 GTID 主从复制后出现错误代码 1785 解决方法 - 程序园
http://www.voidcn.com/article/p-ajcjwjuo-sb.html

MySQL :: MySQL 5.6 Reference Manual :: 17.1.4.5 Global Transaction ID Options and Variables
https://dev.mysql.com/doc/refman/5.6/en/replication-options-gtids.html

mysql Statement violates GTID consistency 的坑 - SheaChen - 博客园
http://www.cnblogs.com/canmeng-cn/p/5969188.html

pinpoint-web not supporting mysql/percona enforce_gtid_consistency · Issue #4034 · naver/pinpoint
https://github.com/naver/pinpoint/issues/4034

MySQL 问题：perror (1875),Statement violates GTID consistency - poxiaonie 的博客 - CSDN 博客
https://blog.csdn.net/poxiaonie/article/details/75073161

执行 MySql 更新报错：error code [1785] - Mergades - CSDN 博客
https://blog.csdn.net/mergades/article/details/46808079

13.3.5 LOCK TABLES and UNLOCK TABLES Statements(mysql 5.7)-内容来自官方文档

LOCK TABLES
    tbl_name [[AS] alias] lock_type
    [, tbl_name [[AS] alias] lock_type] ...
lock_type: {
    READ [LOCAL]
  | [LOW_PRIORITY] WRITE
}
UNLOCK TABLES

mysql允许client session显示的获取表锁，用于访问表时，与其他session的协作，或者阻止其他session修改表。一个session获取、释放锁都是仅针对自身而言的。一个session不能获取其他session的锁，也不能释放其他session的锁。

LOCK TABLES 语句显示的为当前session获取表锁。表锁可用于表或视图。需要有LOCK TABLE权限和SELECT权限。

对于视图锁，视图用到的所有表都会自动锁住。如果你使用 LOCK TABLES 显示的锁住某个表，那么该表的触发器中用到的所有表，都会被隐式的锁住（下文有示例）。

UNLOCK TABLES 语句显示的释放当前session的所有表锁。 LOCK TABLES 语句隐式的释放当前session之前获取的锁。

UNLOCK TABLES 还用于释放由 FLUSH TABLES WITH READ LOCK （锁住所有数据库的所有表）获取的全局读锁。

表锁是为了防止其他session的不适当的读写操作。一个拥有WRITE锁的session，可以执行表级操作，如 DROP TABLE 或者 TRUNCATE TABLE ，一个拥有READ锁的session，这两个操作是不允许的。

LOCK TABLE 仅适用于non-TEMPORARY表。

Table Lock Acquisition

LOCK TABLES 用于获取表锁，通过获取metadata lock来实现。

可用的锁类型如下：

READ [LOCAL] lock：

可以读取表，但是不能写。
多个session，可以同时获取某个表的READ锁。
其他没有显示的获取READ锁的session，也可以读取该表。
LOCAL修饰符，使得在当前会话已经持有READ锁时，其他会话可以执行不冲突的插入语句(并发插入)。对于InnoDB表，READ LOCAL和READ是一样的。

[LOW_PRIORITY] WRITE lock：

既可以进行读操作、也可以进行写操作。
仅持有锁的session可以访问表。
当已经有一个session持有该锁时，其他获取锁的请求会阻塞。
LOW_PRIORITY不起作用，这是老版本的东西，现在已经弃用了，不生效了。

WRITE锁比READ锁优先级更高，这是为了确保写操作可以尽快的执行。也就是说，一个session已经获取了READ锁，另一个session请求WRITE锁，后续的READ锁请求会阻塞，直到请求WRITE锁的session获取然后又释放WRITE锁后，才会继续READ锁请求的执行（An exception to this policy can occur for small values of the max_write_lock_count system variable）。

一个需要锁的session，必须在一个 LOCK TABLES 语句中获取需要的全部锁。获取锁后，这个session仅可以访问 LOCK TABLES 语句中包含的表。例如：下面的语句中，访问 t2 会报错，因为没有在 LOCK TABLES 语句中锁住该表：

mysql> LOCK TABLES t1 READ;
mysql> SELECT COUNT(*) FROM t1;
+----------+
| COUNT(*) |
+----------+
|        3 |
+----------+
mysql> SELECT COUNT(*) FROM t2;
ERROR 1100 (HY000): Table ''t2'' was not locked with LOCK TABLES

INFORMATION_SCHEMA 数据库中的表是一个例外情况，哪怕在使用了 LOCK TABLES 语句，却未包含时，也可以访问这个数据库中的表。

如果操作某个表时使用的是别名，那么在使用 LOCK TABLES 锁表时，也必须使用相同的别名，否则会报错，示例如下：

mysql> LOCK TABLE t READ;
mysql> SELECT * FROM t AS myalias;
ERROR 1100: Table ''myalias'' was not locked with LOCK TABLES

相反的，如果 LOCK TABLES 语句使用的是别名，那么在操作此表的SQL中，也必须使用相同的别名，示例如下：

mysql> LOCK TABLE t AS myalias READ;
mysql> SELECT * FROM t;
ERROR 1100: Table ''t'' was not locked with LOCK TABLES
mysql> SELECT * FROM t AS myalias;

注意： LOCK TABLES 和 UNLOCK TABLES 语句用于分区表时，必须锁住整个表，不能仅是单独锁某个分表。

Table Lock Release

当一个session释放表锁时，该session拥有的多个表锁（如果有多个的话）同时释放。session可以显示的释放锁，也可以在某些条件下隐式的释放锁。

使用 UNLOCK TABLES 显示的释放表锁。
如果已经包含了某些锁的session，执行 LOCK TABLES 语句时，那么在新申请的锁被授权之前，现存的锁会隐式的释放掉。
当一个session开启一个事务（例如，使用 START TRANSACTION 语句）时，会执行一个隐式的 UNLOCK TABLES ，释放掉现存的锁。

如果一个session的连接中断，不论是正常中断还是异常中断，server会隐式的释放掉该session（事务的或非事务的）持有的所有锁。客户端重连后，之前的锁也都不在了。如果client有一个激活的事务，那么在连接断开时，server会将事务回滚，客户端重连时，session会以启用 autocommit=1 的状态开始。因为这个原因，客户端可能想要禁用auto-reconnect。当auto-reconnect禁用时，如果连接断开，那么下一条语句执行时会报错。客户端可以探测到这个错误，然后做出合适的反应，如重新获取锁，或重新开始事务。

注意：如果你对一个锁住的表，执行 ALTER TABLE 语句时，这个表会变为解锁状态。当再次执行第二次的 ALTER TABLE 时，则会报错： Table ''tbl_name'' was not locked with LOCK TABLES ，为解决此问题，在第二次的语句前，先执行锁表语句 LOCK TABLES 。

Interaction of Table Locking and Transactions

LOCK TABLES 和 UNLOCK TABLES 语句与事务的相互影响如下：

LOCK TABLES 不是transaction-safe的，该语句在尝试锁表之前，会隐式的提交任何激活的事务。
UNLOCK TABLES 会隐式的提交任何激活的事务，但仅在已经使用 LOCK TABLES 锁住某些表的情况下，执行该语句，才会如此。例如，在下面的语句之后，执行该语句，不会提交事务：
```
FLUSH TABLES WITH READ LOCK;
START TRANSACTION;
SELECT ... ;
UNLOCK TABLES;
```
开始一个事务，例如使用 START TRANSACTION 语句，会隐式的提交任何当前事务，并释放当前存在的表锁。
FLUSH TABLES WITH READ LOCK 获取一个全局读锁，而不是表锁，所以，不受上述影响。例如 START TRANSACTION 语句不会释放全局读锁。
其他的导致事务隐式提交的语句，不会释放表锁。
在事务型表（如InnoDB表）上正确的使用 LOCK TABLES 和 UNLOCK TABLES 的方法是：使用 SET autocommit = 0 开启事务（注意不是 START TRANSACTION ），然后使用 LOCK TABLES ，直到显示的提交事务后，调用 UNLOCK TABLES 。示例如下：
```
SET autocommit=0;
LOCK TABLES t1 WRITE, t2 READ, ...;... do something with tables t1 and t2 here ...
COMMIT;
UNLOCK TABLES;
```
当调用 LOCK TABLES 时，InnoDB使用自己内部的锁，MySQL也使用自己的锁。在下一个commit时，InnoDB会释放自己内部的锁，但是要让MySQL释放锁，必须调用 UNLOCK TABLES 。不要使用 autocommit = 1 ，因为这样InnoDB会在 LOCK TABLES 语句后立即释放其内部的锁，死锁会非常容易出现。
ROLLBACK 不会释放表锁。

LOCK TABLES and Triggers

如果使用 LOCK TABLES 进行了锁表，那么该表的触发器中用到的所有表，都被隐式的锁住：

这些锁，与 LOCK TABLES 获取的表锁，是同时的。
触发器中用到的表，要加什么锁，取决于该表是否只用于读操作。如果是，那么只加一个READ锁就够了，如果不是，那么就需要加一个WRITE锁。
如果一个表，显示的通过 LOCK TABLES 加了READ锁，但是如果在触发器中，该表可能会被修改，那么就会加上WRITE锁，而不是加READ锁。

下面是一个示例。

锁住两个表t1和t2：

LOCK TABLES t1 WRITE, t2 READ;

假设t1表有一个触发器，如下：

CREATE TRIGGER t1_a_ins AFTER INSERT ON t1 FOR EACH ROW
BEGIN
  UPDATE t4 SET count = count+1
      WHERE id = NEW.id AND EXISTS (SELECT a FROM t3);
  INSERT INTO t2 VALUES(1, 2);
END;

t1和t2会被锁住，因为它们包含在了 LOCK TABLES 语句中。t3和t4也会被锁，因为触发器用到了它们。

t1，WRITE锁。
t2，WRITE锁，虽然在 LOCK TABLES 语句中加的是READ锁。发生这种情况是因为，触发器中尝试向t2表中插入数据，所以READ锁转换成了WRITE锁。
t3，READ锁。因为在触发器中仅对t3进行了读取操作。
t4，WRITE锁。因为在触发器中尝试更新t4的数据。

Table-Locking Restrictions and Conditions

你可以使用 KILL 安全的停止一个正在等待table lock的session。

LOCK TABLE 和 UNLOCK TABLES 不能用于存储程序，如存储过程，存储函数等。

performance_schema 数据库中的表不能使用 LOCK TABLES 语句进行锁定，除了 setup_xxx 表。

在 LOCK TABLES 生效时，下面的语句是被禁止执行的：CREATE TABLE、CREATE TABLE ... LIKE、CREATE VIEW、DROP VIEW、stored functions/procedures/events的DDL语句。

对于某些操作来说， mysql 库中的系统表必须是可访问的。例如， HELP 语句需要访问help tables，CONVERT_TZ()需要读取time zone tables。你不需要显示的对这些表进行锁定操作，因为在必要的情况下，server会隐式的对这些表加READ锁。例如下述的这些表：

mysql.help_category
mysql.help_keyword
mysql.help_relation
mysql.help_topic
mysql.proc
mysql.time_zone
mysql.time_zone_leap_second
mysql.time_zone_name
mysql.time_zone_transition
mysql.time_zone_transition_type

如果对这些表，你需要WRITE锁，则要使用 LOCK TABLES 语句显示的锁表。

通常的，你不需要锁表，因为所有的单个的 UPDATE 语句都是原子性的。其他的session不会妨碍语句的执行。

然而，有一些情况是需要进行锁表的：

如果你正在对一些 MyISAM 表进行很多操作，锁表可以使操作更快速。因为直到执行 UNLOCK TABLES 语句，MySQL不会刷新key cache。如果不锁表，那么每一条语句执行完，都会进行key cache的刷新。某些情况，锁表的也会有负面影响，因为对于加了READ锁的表，所有的session都不能对其进行更改，即使是持有锁的session也不可以进行更改；对于加了WRITE锁的表，除了持有锁的session，其他的session对此表都不可访问（读、写均不可以）。
如果你在使用非事务型的表，如果你想确保，在你执行SELECT和UPDATE语句之间，没有其他session会修改这个表，则必须使用 LOCK TABLES 。下面是一个示例，这个示例需要使用使用 LOCK TABLES ：
```
LOCK TABLES trans READ, customer WRITE;
SELECT SUM(value) FROM trans WHERE customer_id=some_id;
UPDATE customer
  SET total_value=sum_from_previous_statement
  WHERE customer_id=some_id;
UNLOCK TABLES;
```

大多情况下，你可以避免使用 LOCK TABLES ，通过使用相对更新（ UPDATE customer SET value=value+new_value ）或者 LAST_INSERT_ID() 方法。

你也可以通过如下方法来避免使用 LOCK TABLES ：user-level锁方法 GET_LOCK() 和 RELEASE_LOCK() 。

- - 结束 - -

@types/tabulator-tables 打破 tabulator-tables 导入

如何解决@types/tabulator-tables 打破 tabulator-tables 导入

安装以下（从 tabulator-tables@4.9.1 开始）：

npm install tabulator-tables
npm install @types/tabulator-tables

然后做下面的导入

import Tabulator from ''tabulator-tables'';

导致错误：Module Usage (Error node_modules @types tabulator tables index.d.ts'' is not a module)。

改用这个导入

import ''tabulator-tables'';

不输出错误，并允许加载类型信息，但在运行时（例如，在 Angular 12 项目中）实际上不允许访问 Tabulator 对象，从而导致 ReferenceError: Tabulator is not defined 之类的错误。>

解决方法

这是由于 @types/tabulator-tables 中的类型定义文件中缺少默认导出。不幸的是，在上游添加默认导出是不可行的，因为它会破坏现有的代码库。

幸运的是，有一个解决方法，described here：如果您还没有创建一个 index.d.ts 文件，然后添加以下行：

declare module "tabulator-tables" { export = Tabulator; }

（还要确保通过在 index.d.ts 中列出 "files" 文件或确保它与 tsconfig.json 中的 "includes" 中的模式匹配来确保包含 "allowSyntheticDefaultImports": true 文件。您可以还需要在 "compilerOptions" 中设置 parenthesis or brackets.。）

a label can only be part of statement and a declaratioin is not a statement

参考资料：

　　https://stackoverflow.com/questions/18496282/why-do-i-get-a-label-can-only-be-part-of-a-statement-and-a-declaration-is-not-a

问题背景：

　　写了一段 code，如下：

#include<stdio.h>

int main()
{
    int a;switch (a) {
        case 0:
            break;
        case 1:
            int aa;
            break;
        case 2:
            break;
        default:
            break;
    }

    return 0;
}

　　如上所示 code 编译时候会报错，错误提示 “a label can only be part of statement and a declaratioin is not a statement”。

问题原因：

　　引用一段话解释为 “Prior to C99, all declarations had to precede all statements within a block, so it wouldn''t have made sense to have a label on a declaration. C99 relaxed that restriction, permitting declarations and statement to be mixed within a block, but the syntax of a labeled-statement was not changed. – Keith Thompson”。

　　翻译过来就是，C99 之前，在一代码块中所有的定义都必须在声明之前，所以，一个标签在定义之前是没有意义的。C99 放宽了这个限制，允许代码块中混合定义、声明，但这这个标签不能在定义之前的限制没有改变。

解决方法：

#include<stdio.h>

int main()
{
    int a;
    switch (a) {
        case 0:
            break;
        case 1:; //加一个空的‘;’，标示空声明
            int aa;
            break;
        case 2:
            break;
        default:
            break;
    }

    return 0;
}

#include<stdio.h>

int main()
{
    int a;
    int aa;    //定义放到 switch 之前
    switch (a) {
        case 0:
            break;
        case 1:
            break;
        case 2:
            break;
        default:
            break;
    }

    return 0;
}

Apache FileUpload的两种上传方式介绍及应用 --> upload file done! --> upload file done!

本文为大家介绍下FileUpload的两种上传方式:Traditional API上传方式/Streaming API上传方式，感兴趣的朋友可以参考下哈，希望可以帮助到你

环境：

tomcat5.6

commmons-fileupload-1.3.jar

commmons-io-2.4.jar

JSP

编码：UTF-8

临时文件夹：fileupload/tmp相对于网站根目录

上传文件保存位置：fileupload

Traditional API上传方式

//fileload01.htm

复制代码代码如下:

File to upload:

to upload the file!

//Traditionalapi.jsp

复制代码代码如下:

request.setCharacterEncoding("UTF-8");

// file less than 10kb will be store in memory, otherwise in file system.

final int threshold = 10240;

final File tmpDir = new File(getServletContext().getRealPath("/") + "fileupload" + File.separator + "tmp");

final int maxRequestSize = 1024 * 1024 * 4; // 4MB

// Check that we have a file upload request

if(ServletFileUpload.isMultipartContent(request))

{

// Create a factory for disk-based file items.

FileItemFactory factory = new diskFileItemFactory(threshold, tmpDir);

// Create a new file upload handler

ServletFileUpload upload = new ServletFileUpload(factory);

// Set overall request size constraint.

upload.setSizeMax(maxRequestSize);

List items = upload.parseRequest(request); // FileUploadException

for(FileItem item : items)

{

if(item.isFormField()) //regular form field

{

String name = item.getFieldName();

String value = item.getString();

-->

}

else

{ //file upload

String fieldName = item.getFieldName();

String fileName = item.getName();

File uploadedFile = new File(getServletContext().getRealPath("/") +

"fileupload" + File.separator + fieldName + "_" + fileName);

item.write(uploadedFile);

upload file done!

}

Streaming API上传方式

//fileupload02.htm

复制代码代码如下:

File to upload:

to upload the file!

//streamingapi.jsp

复制代码代码如下:

request.setCharacterEncoding("UTF-8");

// Check that we have a file upload request

if(ServletFileUpload.isMultipartContent(request))

{

// Create a new file upload handler

ServletFileUpload upload = new ServletFileUpload();

// Parse the request

FileItemIterator iter = upload.getItemIterator(request);

while(iter.hasNext())

{

FileItemStream item = iter.next();

String fieldName = item.getFieldName();

InputStream is = item.openStream();

if(item.isFormField()) //regular form field

{

-->

}

else

{ //file upload

String fileName = item.getName();

File uploadedFile = new File(getServletContext().getRealPath("/") +

"fileupload" + File.separator + fieldName + "_" + fileName);

OutputStream os = new FileOutputStream(uploadedFile);

// write file to disk and close outputstream.

Streams.copy(is, os, true);

upload file done!

}

Traditional API vs Streaming API

Streaming API上传速度相对较快。因为它是利用内存保存上传的文件，节省了传统API将文件写入临时文件带来的开销。

可参考：

http://stackoverflow.com/questions/11620432/apache-commons-fileupload-streaming-api

This page describes the Traditional API of the commons fileupload library. The Traditional API is a convenient approach. However, for ultimate performance, you might prefer the faster Streaming API.

http://commons.apache.org/proper/commons-fileupload/using.html

关于MYSQL Statement violates GTID consistency: Updates to non-transactional tables can only be done i...的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于13.3.5 LOCK TABLES and UNLOCK TABLES Statements(mysql 5.7)-内容来自官方文档、@types/tabulator-tables 打破 tabulator-tables 导入、a label can only be part of statement and a declaratioin is not a statement、Apache FileUpload的两种上传方式介绍及应用 --> upload file done! --> upload file done!的相关知识，请在本站寻找。

本文标签：