{"action":"created","issue":{"url":"https://api.github.com/repos/owncloud/core/issues/7769","labels_url":"https://api.github.com/repos/owncloud/core/issues/7769/labels{/name}","comments_url":"https://api.github.com/repos/owncloud/core/issues/7769/comments","events_url":"https://api.github.com/repos/owncloud/core/issues/7769/events","html_url":"https://github.com/owncloud/core/issues/7769","id":29573713,"number":7769,"title":"MariaDB logs an \"Unsafe statement written to the binary log\"","user":{"login":"ervee","id":4435930,"avatar_url":"https://avatars.githubusercontent.com/u/4435930?v=3","gravatar_id":"","url":"https://api.github.com/users/ervee","html_url":"https://github.com/ervee","followers_url":"https://api.github.com/users/ervee/followers","following_url":"https://api.github.com/users/ervee/following{/other_user}","gists_url":"https://api.github.com/users/ervee/gists{/gist_id}","starred_url":"https://api.github.com/users/ervee/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/ervee/subscriptions","organizations_url":"https://api.github.com/users/ervee/orgs","repos_url":"https://api.github.com/users/ervee/repos","events_url":"https://api.github.com/users/ervee/events{/privacy}","received_events_url":"https://api.github.com/users/ervee/received_events","type":"User","site_admin":false},"labels":[{"url":"https://api.github.com/repos/owncloud/core/labels/bug","name":"bug","color":"fc2929"},{"url":"https://api.github.com/repos/owncloud/core/labels/db:mysql","name":"db:mysql","color":"444444"}],"state":"open","locked":false,"assignee":null,"milestone":{"url":"https://api.github.com/repos/owncloud/core/milestones/31","html_url":"https://github.com/owncloud/core/milestones/8.1-current","labels_url":"https://api.github.com/repos/owncloud/core/milestones/31/labels","id":912160,"number":31,"title":"8.1-current","description":"","creator":{"login":"MorrisJobke","id":245432,"avatar_url":"https://avatars.githubusercontent.com/u/245432?v=3","gravatar_id":"","url":"https://api.github.com/users/MorrisJobke","html_url":"https://github.com/MorrisJobke","followers_url":"https://api.github.com/users/MorrisJobke/followers","following_url":"https://api.github.com/users/MorrisJobke/following{/other_user}","gists_url":"https://api.github.com/users/MorrisJobke/gists{/gist_id}","starred_url":"https://api.github.com/users/MorrisJobke/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/MorrisJobke/subscriptions","organizations_url":"https://api.github.com/users/MorrisJobke/orgs","repos_url":"https://api.github.com/users/MorrisJobke/repos","events_url":"https://api.github.com/users/MorrisJobke/events{/privacy}","received_events_url":"https://api.github.com/users/MorrisJobke/received_events","type":"User","site_admin":false},"open_issues":149,"closed_issues":1001,"state":"open","created_at":"2014-12-22T12:04:01Z","updated_at":"2015-05-05T17:11:36Z","due_on":"2015-04-02T22:00:00Z","closed_at":null},"comments":22,"created_at":"2014-03-17T16:08:20Z","updated_at":"2015-05-05T17:48:00Z","closed_at":null,"body":"Hi,\r\n\r\nI'm running ownCloud 6.0.1 (stable) without much issues on my Debian Wheezy Server. But sometimes the DB Server (MariaDB Version: 5.5.36+maria-1~wheezy) logs an \"Unsafe statement written to the binary log\". I could not find other people with this error here or via Google.\r\n\r\nI don't notice anything wrong with this, but still wanted to share this with you to examine. Am I doing something whong? Or is there an error in the ownCloud source doing something wrong?\r\n\r\n```\r\nFeb 10 21:24:56 ##### mysqld: 140210 21:24:56 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 10 21:24:56 ##### mysqld: 140210 21:24:56 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 10 21:24:56 ##### mysqld: 140210 21:24:56 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 10 21:24:56 ##### mysqld: 140210 21:24:56 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 15 23:24:14 ##### mysqld: 140215 23:24:14 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 15 23:24:14 ##### mysqld: 140215 23:24:14 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 15 23:24:14 ##### mysqld: 140215 23:24:14 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 15 23:24:14 ##### mysqld: 140215 23:24:14 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 16 18:20:12 ##### mysqld: 140216 18:20:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 16 18:20:12 ##### mysqld: 140216 18:20:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 16 18:20:12 ##### mysqld: 140216 18:20:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 16 18:20:12 ##### mysqld: 140216 18:20:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 16 18:21:12 ##### mysqld: 140216 18:21:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 16 18:21:12 ##### mysqld: 140216 18:21:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 16 18:21:12 ##### mysqld: 140216 18:21:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 16 18:21:12 ##### mysqld: 140216 18:21:12 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 16 18:38:05 ##### mysqld: 140216 18:38:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 16 18:38:05 ##### mysqld: 140216 18:38:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 16 18:38:05 ##### mysqld: 140216 18:38:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 16 18:38:05 ##### mysqld: 140216 18:38:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 16 18:46:11 ##### mysqld: 140216 18:46:11 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 16 18:46:11 ##### mysqld: 140216 18:46:11 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 16 18:46:11 ##### mysqld: 140216 18:46:11 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 16 18:46:11 ##### mysqld: 140216 18:46:11 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 19 13:24:03 ##### mysqld: 140219 13:24:03 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 19 13:24:03 ##### mysqld: 140219 13:24:03 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 19 13:24:03 ##### mysqld: 140219 13:24:03 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 19 13:24:03 ##### mysqld: 140219 13:24:03 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 20 14:51:32 ##### mysqld: 140220 14:51:32 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 20 14:51:32 ##### mysqld: 140220 14:51:32 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 20 14:51:32 ##### mysqld: 140220 14:51:32 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 20 14:51:32 ##### mysqld: 140220 14:51:32 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nFeb 20 21:23:05 ##### mysqld: 140220 21:23:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nFeb 20 21:23:05 ##### mysqld: 140220 21:23:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nFeb 20 21:23:05 ##### mysqld: 140220 21:23:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nFeb 20 21:23:05 ##### mysqld: 140220 21:23:05 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nMar  3 07:39:15 ##### mysqld: 140303  7:39:15 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nMar  3 07:39:15 ##### mysqld: 140303  7:39:15 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nMar  3 07:39:15 ##### mysqld: 140303  7:39:15 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nMar  3 07:39:15 ##### mysqld: 140303  7:39:15 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nMar 12 13:09:39 ##### mysqld: 140312 13:09:39 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Family' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Family' HAVING COUNT(*) = 0\r\nMar 12 13:09:39 ##### mysqld: 140312 13:09:39 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Friends' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Friends' HAVING COUNT(*) = 0\r\nMar 12 13:09:39 ##### mysqld: 140312 13:09:39 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Other' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Other' HAVING COUNT(*) = 0\r\nMar 12 13:09:39 ##### mysqld: 140312 13:09:39 [Warning] Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave. Statement: INSERT INTO `oc_vcategory` (`uid`,`type`,`category`) SELECT '#####','contact','Work' FROM `oc_vcategory` WHERE `uid` = '#####' AND `type` = 'contact' AND `category` = 'Work' HAVING COUNT(*) = 0\r\nPS, the first ##### per log rule is the hostname of the DB Server and the 2 other are my username in ownCloud.\r\n```\r\nAs you can see this does not happen huch and so I can't get when exactly this happens.\r\n\r\nYours,\r\nRalf."},"comment":{"url":"https://api.github.com/repos/owncloud/core/issues/comments/99156571","html_url":"https://github.com/owncloud/core/issues/7769#issuecomment-99156571","issue_url":"https://api.github.com/repos/owncloud/core/issues/7769","id":99156571,"user":{"login":"ervee","id":4435930,"avatar_url":"https://avatars.githubusercontent.com/u/4435930?v=3","gravatar_id":"","url":"https://api.github.com/users/ervee","html_url":"https://github.com/ervee","followers_url":"https://api.github.com/users/ervee/followers","following_url":"https://api.github.com/users/ervee/following{/other_user}","gists_url":"https://api.github.com/users/ervee/gists{/gist_id}","starred_url":"https://api.github.com/users/ervee/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/ervee/subscriptions","organizations_url":"https://api.github.com/users/ervee/orgs","repos_url":"https://api.github.com/users/ervee/repos","events_url":"https://api.github.com/users/ervee/events{/privacy}","received_events_url":"https://api.github.com/users/ervee/received_events","type":"User","site_admin":false},"created_at":"2015-05-05T17:47:59Z","updated_at":"2015-05-05T17:47:59Z","body":"@bantu I have my own Server without MySQL replication but do have the errors in my logs on a default configuration."}}