flydata 0.2.7 → 0.2.8

data/lib/flydata/util/encryptor.rb

@@ -9,7 +9,7 @@ module Flydata
         def encrypt(text, key)
           validate_presence(text: text, key: key)
           cipher = build_cipher(:encrypt, key)
-          Base64.encode64(cipher.update(text) + cipher.final)
+          Base64.strict_encode64(cipher.update(text) + cipher.final)
         end
 
         def decrypt(text, key, param_name = nil)

data/spec/flydata/fluent-plugins/in_mysql_binlog_flydata_spec.rb

@@ -105,6 +105,10 @@ EOT
   # QUERY: alter table modify column
   TEST_EVENT_QUERY_ALTER_TABLE_MODIFY_COLUMN = <<EOT
 {"marker"=>0, "timestamp"=>#{TEST_TIMESTAMP}, "type_code"=>2, "server_id"=>1, "event_length"=>112, "next_position"=>1352, "flags"=>0, "event_type"=>"Query", "thread_id"=>48, "exec_time"=>0, "error_code"=>0, "variables"=>[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 6, 3, 115, 116, 100, 4, 33, 0, 33, 0, 8, 0], "db_name"=>"test_db", "query"=>"alter table test_table modify column sum float"}
+EOT
+  # QUERY: alter table add index
+  TEST_EVENT_QUERY_ALTER_TABLE_ADD_INDEX = <<EOT
+{"marker"=>0, "timestamp"=>#{TEST_TIMESTAMP}, "type_code"=>2, "server_id"=>1, "event_length"=>217, "next_position"=>337, "flags"=>0, "event_type"=>"Query", "thread_id"=>10097, "exec_time"=>0, "error_code"=>0, "variables"=>[0, 0, 0, 0, 0, 1, 0, 0, 0, 64, 0, 0, 0, 0, 6, 3, 115, 116, 100, 4, 33, 0, 33, 0, 8, 0, 12, 1, 109, 97, 107, 95, 100, 101, 118, 101, 108, 111, 112, 109, 101, 110, 116, 0], "db_name"=>"test_db", "query"=>"ALTER TABLE `test_db`.`test_table` \nADD INDEX `my_index` USING HASH (`extra` ASC)  COMMENT 'How does this look in binlog?'"}
 EOT
   # - 03 STOP_EVENT
   TEST_EVENT_STOP = <<EOT
@@ -179,6 +183,7 @@ EOT
     let(:update_three_byte_event) { create_event(TEST_EVENT_THREE_BYTE_UPDATE) }
     let(:alter_table_add_column_event) { create_event(TEST_EVENT_QUERY_ALTER_TABLE_ADD_COLUMN) }
     let(:alter_table_drop_column_event) { create_event(TEST_EVENT_QUERY_ALTER_TABLE_DROP_COLUMN) }
+    let(:alter_table_add_index_event) { create_event(TEST_EVENT_QUERY_ALTER_TABLE_ADD_INDEX) }
 
     let(:query_event) { create_event(TEST_EVENT_QUERY_CREATE_DATABSE) }
     let(:table_map_event) { create_event(TEST_EVENT_TABLE_MAP) }
@@ -309,7 +314,7 @@ EOT
               table_rev: 2,  # increment revision
               seq: 2,
               actions: [{
-                action: :add_column, column: "sum", :type=>'int4'}],
+                action: :add_column, column: "sum", :type=>'int4', :query=>'add column sum integer'}],
             })
           end
         end
@@ -324,7 +329,26 @@ EOT
               table_rev: 2,  # increment revision
               seq: 2,
               actions: [{
-                action: :drop_column, column: "sum"}],
+                action: :drop_column, column: "sum", :query=>'drop column sum'}],
+            })
+          end
+        end
+
+        context 'when received alter table add index event' do
+          it 'emits a nonbreaking event without table_rev increment' do
+            expect_emitted_records(alter_table_add_index_event, {
+              type: :alter_table,
+              table_name: "test_table",
+              schema_name: "test_db",
+              respect_order: true,
+              src_pos: "mysql-bin.000048\t#{337 - 217}",
+              table_rev: 1,
+              seq: 2,
+              actions: [{
+                action: :add_index,
+                support_level: :nonbreaking,
+                query: "ADD INDEX `my_index` USING HASH (`extra` ASC)  COMMENT 'How does this look in binlog?'",
+              }],
             })
           end
         end

data/spec/flydata/fluent-plugins/mysql/alter_table_query_handler_spec.rb

@@ -69,7 +69,7 @@ module Mysql
           expect(parser).to receive(:parse).and_return(nil)
         end
         it "returns nil with a warn log" do
-          expect($log).to receive(:warn).with(/Received unsupported alter table query\. query:'#{query}'/)
+          expect($log).to receive(:error).with(/Received unsupported alter table query\. query:'#{query}'/)
 
           expect(subject.process(record, normalized_query)).to eq(nil)
         end

data/spec/flydata/parser/mysql/alter_table_parser_spec.rb

@@ -25,7 +25,8 @@ describe 'MysqlAlterTableParser' do
             actions: [{
               action: :add_column,
               column: "value",
-              type: "varchar(78)"
+              type: "varchar(78)",
+              query: "add column value varchar(26)"
             }]
           })
         end
@@ -41,7 +42,8 @@ describe 'MysqlAlterTableParser' do
               actions: [{
                 action: :add_column,
                 column: "value",
-                type: "varbinary(4294967295)"
+                type: "varbinary(4294967295)",
+                query: "add column value longblob"
               }]
             })
           end
@@ -57,28 +59,42 @@ describe 'MysqlAlterTableParser' do
             actions: [{
               action: :add_column,
               column: "value",
-              type: "varchar(78)"
+              type: "varchar(78)",
+              query: "add value varchar(26)"
             }]
           })
         end
       end
 
       context 'with multiple columns' do
-        let(:query) { "alter table test_table add column (value1 varchar(26), value2 varchar(26))" }
-        it do
-          expect(subject).to eq({
-            type: :alter_table,
-            table_name: "test_table",
-            actions: [{
-              action: :add_column,
-              column: "value1",
-              type: "varchar(78)"
-            },{
-              action: :add_column,
-              column: "value2",
-              type: "varchar(78)"
-            }]
-          })
+        shared_examples 'test result hash' do
+          it do
+            expect(subject).to eq({
+              type: :alter_table,
+              table_name: "test_table",
+              actions: [{
+                action: :add_column,
+                column: "value1",
+                type: "varchar(78)",
+                query: "#{expected_query}"
+              },{
+                action: :add_column,
+                column: "value2",
+                type: "varchar(78)",
+                query: "#{expected_query}"
+              }]
+            })
+          end
+        end
+        context 'with spaces before opening bracket' do
+          let(:query) { "alter table test_table add column (value1 varchar(26), value2 varchar(26))" }
+          let(:expected_query) {"add column (value1 varchar(26), value2 varchar(26))"}
+          include_examples 'test result hash'
+        end
+        context 'without spaces before opening bracket' do
+          let(:query) { "alter table test_table add column(value1 varchar(26), value2 varchar(26))" }
+          let(:expected_query) {"add column(value1 varchar(26), value2 varchar(26))"}
+          include_examples 'test result hash'
         end
       end
 
@@ -91,11 +107,13 @@ describe 'MysqlAlterTableParser' do
             actions: [{
               action: :add_column,
               column: "value1",
-              type: "varchar(78)"
+              type: "varchar(78)",
+              query: "add ( value1 varchar(26), value2 varchar(26) )"
             },{
               action: :add_column,
               column: "value2",
-              type: "varchar(78)"
+              type: "varchar(78)",
+              query: "add ( value1 varchar(26), value2 varchar(26) )"
             }]
           })
         end
@@ -113,11 +131,13 @@ describe 'MysqlAlterTableParser' do
               type: "varchar(78)",
               not_null: true,
               default: "flydata",
+              query: "add (value1 varchar(26) not null default 'flydata', value2 int auto_increment)"
             },{
               action: :add_column,
               column: "value2",
               type: "int4",
               auto_increment: true,
+              query: "add (value1 varchar(26) not null default 'flydata', value2 int auto_increment)"
             }]
           })
         end
@@ -135,11 +155,13 @@ describe 'MysqlAlterTableParser' do
               type: "varchar(78)",
               not_null: true,
               default: "flydata",
+              query: "add (`value1` varchar(26) not null default 'flydata', `value2` int auto_increment)"
             },{
               action: :add_column,
               column: "value2",
               type: "int4",
               auto_increment: true,
+              query: "add (`value1` varchar(26) not null default 'flydata', `value2` int auto_increment)"
             }]
           })
         end
@@ -156,13 +178,15 @@ describe 'MysqlAlterTableParser' do
               column: "value",
               type: "varchar(78)",
               after: 'id',
+              query: "add column value varchar(26) after id"
             }]
           })
         end
       end
-
-      context 'with after option, backticks only on table name and a comment' do
-        let(:query) { %Q|alter table `test_table` add column value varchar(26) comment 'Ignorable comment' after id| }
+      shared_examples "generating a flydata record for the given query" do
+        let(:after_column_name) { 'id' }
+        let(:actions) { %Q|add column value varchar(26) comment 'Ignorable comment' after #{after_column}| }
+        let(:query) { %Q|alter table `test_table` #{actions}| }
         it do
           expect(subject).to eq({
             type: :alter_table,
@@ -171,11 +195,23 @@ describe 'MysqlAlterTableParser' do
               action: :add_column,
               column: "value",
               type: "varchar(78)",
-              after: 'id',
+              after: after_column_name,
+              query: actions
             }]
           })
         end
       end
+      context 'with after option, quoted after column name' do
+        let(:after_column) { "`#{after_column_name}`" }
+
+        it_behaves_like "generating a flydata record for the given query"
+      end
+
+      context 'with after option, backticks only on table name and a comment' do
+        let(:after_column) { after_column_name }
+
+        it_behaves_like "generating a flydata record for the given query"
+      end
 
       context 'with first option' do
         let(:query) { "alter table test_table add column value varchar(26) first" }
@@ -188,6 +224,7 @@ describe 'MysqlAlterTableParser' do
               column: "value",
               type: "varchar(78)",
               position: :first,
+              query: "add column value varchar(26) first"
             }]
           })
         end
@@ -205,6 +242,7 @@ describe 'MysqlAlterTableParser' do
               type: "varchar(78)",
               unique: true,
               position: :first,
+              query: "add column value varchar(26) UNIQUE first"
             }]
           })
         end
@@ -214,7 +252,7 @@ describe 'MysqlAlterTableParser' do
         shared_examples "a query parser parsing a query adding a column with a default value" do
           let(:query) { "alter table test_table add column col #{data_type} default #{value}" }
           it do
-            expect(subject).to eq({
+            is_expected.to eq({
               type: :alter_table,
               table_name: "test_table",
               actions: [{
@@ -222,108 +260,109 @@ describe 'MysqlAlterTableParser' do
                 column: "col",
                 type: expected_data_type,
                 default: expected_value,
+                query: "add column col #{data_type} default #{value}"
               }]
             })
           end
         end
-  
+
         context 'for timestamp column' do
           let(:data_type) { "timestamp" }
           let(:expected_data_type) { "datetime" }
           context 'taking current_timestamp' do
             let(:value) { "current_timestamp" }
             let(:expected_value) { "current_timestamp" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking localtime' do
             let(:value) { "localtime" }
             let(:expected_value) { "current_timestamp" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking localtimestamp' do
             let(:value) { "localtimestamp" }
             let(:expected_value) { "current_timestamp" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking now()' do
             let(:value) { "now()" }
             let(:expected_value) { "current_timestamp" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
         end
-  
+
         context 'for integer column' do
           let(:data_type) { "int(11)" }
           let(:expected_data_type) { "int4(11)" }
-  
+
           context 'taking a positive number without sign' do
             let(:value) { "1" }
             let(:expected_value) { "1" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a positive number' do
             let(:value) { "+1" }
             let(:expected_value) { "1" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a negative number' do
             let(:value) { "-1" }
             let(:expected_value) { "-1" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a negative number string' do
             let(:value) { %Q|'-1'| }
             let(:expected_value) { "-1" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking null' do
             let(:value) { %Q|NULL| }
             let(:expected_value) { nil }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
         end
-  
+
         context 'for decimal column' do
           let(:data_type) { "decimal(10,2)" }
           let(:expected_data_type) { "numeric(10,2)" }
-  
+
           context 'taking a positive number without sign' do
             let(:value) { "2.4" }
             let(:expected_value) { "2.4" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a positive number with sign' do
             let(:value) { "+0.4" }
             let(:expected_value) { "0.4" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a positive number no integer part' do
             let(:value) { ".05" }
             let(:expected_value) { "0.05" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a negative number' do
             let(:value) { "-20.43" }
             let(:expected_value) { "-20.43" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a negative number no integer part' do
             let(:value) { "-.43" }
             let(:expected_value) { "-0.43" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
         end
@@ -331,35 +370,35 @@ describe 'MysqlAlterTableParser' do
         context 'for varchar column' do
           let(:data_type) { "varchar(10)" }
           let(:expected_data_type) { "varchar(30)" }
-  
+
           context 'taking null' do
             let(:value) { "NULL" }
             let(:expected_value) { nil }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking empty string' do
             let(:value) { %Q|''| }
             let(:expected_value) { "" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a string with spaces' do
             let(:value) { %Q|'0 0 0 0 0 0 0'| }
             let(:expected_value) { "0 0 0 0 0 0 0" }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a backslash' do
             let(:value) { %q|'\\\\'| }
             let(:expected_value) { %q|\\\\| }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
           context 'taking a string with special characters' do
             let(:value) { %q|'https://flydata.com $ \\\\\'\"\n\t'| }
             let(:expected_value) { %q|https://flydata.com $ \\\\\'\"\n\t| }
-  
+
             it_behaves_like "a query parser parsing a query adding a column with a default value"
           end
         end
@@ -376,6 +415,7 @@ describe 'MysqlAlterTableParser' do
               action: :add_column,
               column: "extra",
               type: "varchar(#{length * 3})",
+              query: "add column extra varchar(#{length}) null"
             }]
           })
         end
@@ -390,7 +430,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop column value"
           }])
       end
     end
@@ -403,7 +444,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop value"
           }])
       end
     end
@@ -416,7 +458,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop `value`"
           }])
       end
     end
@@ -429,7 +472,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop value"
           }])
       end
     end
@@ -442,7 +486,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "DROP value"
           }])
       end
     end
@@ -456,7 +501,8 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop value"
           }])
       end
     end
@@ -470,35 +516,12 @@ describe 'MysqlAlterTableParser' do
           table_name: "test_table",
           actions: [{
             action: :drop_column,
-            column: "value"
+            column: "value",
+            query: "drop `value`"
           }])
       end
     end
 
-    context 'when query has unsupported drop dextension' do
-      subject { parser.parse(query) }
-
-      context 'with primary key drop' do
-        let(:query) { "alter table test_table drop PRIMARY KEY" }
-        it { expect(subject).to be_nil }
-      end
-
-      context 'with index drop' do
-        let(:query) { "alter table test_table drop Index index_name" }
-        it { expect(subject).to be_nil }
-      end
-
-      context 'with key drop' do
-        let(:query) { "alter table test_table drop  key  index_name" }
-        it { expect(subject).to be_nil }
-      end
-
-      context 'with foreign key drop' do
-        let(:query) { "alter table test_table drop  foreign key foreign_key_name" }
-        it { expect(subject).to be_nil }
-      end
-    end
-
     context 'with multiple alter specs' do
       context 'with add column and drop column' do
         let(:query) { "alter table test_table add column value varchar(26) after id, drop old_value" }
@@ -511,13 +534,408 @@ describe 'MysqlAlterTableParser' do
               column: "value",
               type: "varchar(78)",
               after: 'id',
+              query: "add column value varchar(26) after id"
             },{
               action: :drop_column,
               column: "old_value",
+              query: "drop old_value"
             }]
           })
         end
       end
     end
+
+    let(:query) { "ALTER TABLE `test_schema`.`test_table` #{alter_table_action}" }
+    shared_examples "a parser parsing a single action alter table query" do
+      it do
+        is_expected.to eq({
+          type: :alter_table,
+          schema_name: "test_schema",
+          table_name: "test_table",
+          actions: [action_hash]
+        })
+      end
+    end
+    shared_examples "a parser parsing a nonbreaking query" do
+      let(:action_hash) {
+          {
+            action: action,
+            support_level: :nonbreaking,
+            query: alter_table_action,
+          }
+      }
+      it_behaves_like "a parser parsing a single action alter table query"
+    end
+    shared_examples "a parser parsing a breaking query" do
+      let(:action_hash) {
+        {
+          action: action,
+          query: alter_table_action,
+        }
+      }
+      it_behaves_like "a parser parsing a single action alter table query"
+    end
+    shared_examples "a debug parser" do
+      it do
+        puts query
+        result = parser.parse(query)
+        p result
+        puts "FAILURE: #{parser.failure_reason}"
+      end
+    end
+    shared_examples "test normal key options" do |*examples|
+      context "with normal key options" do
+        context "key_block_size" do
+          let(:normal_key_options) { " KEY_BLOCK_SIZE = 102400" }
+          it_behaves_like *examples
+        end
+        context "key_block_size with no space" do
+          let(:normal_key_options) { " KEY_BLOCK_SIZE=102400" }
+          it_behaves_like *examples
+        end
+        context "key_block_size no equal sign" do
+          let(:normal_key_options) { " KEY_BLOCK_SIZE 102400" }
+          it_behaves_like *examples
+        end
+        context "using" do
+          let(:normal_key_options) { " using btree" }
+          it_behaves_like *examples
+        end
+        context "comment" do
+          let(:normal_key_options) { " comment 'Hello World!'" }
+          it_behaves_like *examples
+        end
+        context "key_block_size and comment" do
+          let(:normal_key_options) { " KEY_BLOCK_SIZE 102400 comment 'Hello World!'" }
+          it_behaves_like *examples
+        end
+        context "none" do
+          it_behaves_like *examples do
+            let(:normal_key_options) { "" }
+          end
+        end
+      end
+    end
+    shared_examples "test key list" do |*examples|
+      context "with a single key" do
+        it_behaves_like *examples do
+          let(:key_list) { " testKey" }
+          let(:expected_key_list) { [ "testKey" ] }
+        end
+      end
+      context "with a quoted single key" do
+        it_behaves_like *examples do
+          let(:key_list) { " `testKey`" }
+          let(:expected_key_list) { [ "testKey" ] }
+        end
+      end
+      context "with multiple keys with order" do
+        it_behaves_like *examples do
+          let(:key_list) { " testKey1 ASC, testKey2 desc" }
+          let(:expected_key_list) { [ "testKey1 asc", "testKey2 desc" ] }
+        end
+      end
+    end
+
+    shared_examples "test constraint keyword" do |*examples|
+      context "with constraint keyword" do
+        context "with constraint name" do
+          it_behaves_like *examples do
+            let(:constraint_keyword) { " CONSTRAINT `chkName`" }
+          end
+        end
+        context "without constraint name" do
+          it_behaves_like *examples do
+            let(:constraint_keyword) { " CONSTRAINT" }
+          end
+        end
+      end
+      context "without constraint keyword" do
+        it_behaves_like  *examples do
+          let(:constraint_keyword) { "" }
+        end
+      end
+    end
+    shared_examples "test key name" do |*examples|
+      context "with key name" do
+        it_behaves_like *examples do
+          let(:key_name) { " testKey" }
+        end
+      end
+      context "without key name" do
+        it_behaves_like *examples do
+          let(:key_name) { "" }
+        end
+      end
+      context "with quoted key name" do
+        it_behaves_like *examples do
+          let(:key_name) { " `testKey`" }
+        end
+      end
+    end
+    shared_examples "test key or index" do |*examples|
+      context "with key" do
+        it_behaves_like *examples do
+          let(:key_or_index) { " KEY" }
+        end
+      end
+      context "with index" do
+        it_behaves_like  *examples do
+          let(:key_or_index) { " index" }
+        end
+      end
+    end
+    shared_examples "test optional key or index" do |*examples|
+      include_examples "test key or index", *examples
+      context "with none" do
+        it_behaves_like *examples do
+          let(:key_or_index) { "" }
+        end
+      end
+    end
+    shared_examples "test using option" do |*examples|
+      context "with BTREE" do
+        it_behaves_like *examples do
+          let(:using_option) { " USING BTREE" }
+        end
+      end
+      context "with hash" do
+        it_behaves_like *examples do
+          let(:using_option) { " using hash" }
+        end
+      end
+      context "with none" do
+        it_behaves_like *examples do
+          let(:using_option) { "" }
+        end
+      end
+    end
+    shared_examples "test field identifier" do |*examples|
+      context "without ." do
+        it_behaves_like "test identifier", *examples do
+          let(:field_ident) { " #{ident}" }
+        end
+      end
+      context "with single ." do
+        it_behaves_like "test identifier", *examples do
+          let(:field_ident) { " #{ident}.#{ident}"}
+        end
+      end
+      context "with two ." do
+        it_behaves_like "test identifier", *examples do
+          let(:field_ident) { " #{ident}.#{ident}.#{ident}" }
+        end
+      end
+    end
+    shared_examples "test identifier" do |*examples|
+      context "unquoted identifier" do
+        it_behaves_like *examples do
+          let(:ident) {"test_ident1"}
+        end
+      end
+      context "quoted identifier" do
+        it_behaves_like *examples do
+          let(:ident) {"`test_ident1`"}
+        end
+      end
+    end
+
+    context 'add index' do
+      let(:action) { :add_index }
+      context "with a simple add index" do
+        let(:alter_table_action) { "ADD INDEX `test` (`t_now`)" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+      end
+      context "with a simple add index and without space before the opening bracket" do
+        let(:alter_table_action) { "ADD INDEX `test`(`t_now`)" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+      end
+      context "with a simple add index with order" do
+        let(:alter_table_action) { "ADD INDEX `test` (`t_now` ASC)" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+      end
+      context "with an add index with multiple fields" do
+        let(:key_list) { "`t_now` ASC, `t_timestamp` DESC" }
+        let(:alter_table_action) { "ADD INDEX `test` (#{key_list})" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+
+        context "with spaces around key list" do
+          let(:key_list) { " `t_now` ASC, `t_timestamp` DESC " }
+          it_behaves_like "a parser parsing a nonbreaking query"
+        end
+
+        context "with a field without order" do
+          let(:key_list) { " `t_now` ASC, `t_timestamp`" }
+          it_behaves_like "a parser parsing a nonbreaking query"
+        end
+      end
+      context "with an add index with no index name" do
+        let(:alter_table_action) { "ADD INDEX (`t_now` ASC)" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+      end
+      context "with an add index with USING" do
+        let(:using_option) { "USING BTREE" }
+        let(:alter_table_action) { "ADD INDEX `test` #{using_option} (`t_now` ASC)" }
+        it_behaves_like "a parser parsing a nonbreaking query"
+
+        context "without index name" do
+          let(:alter_table_action) { "ADD INDEX #{using_option} (`t_now` ASC)" }
+          it_behaves_like "a parser parsing a nonbreaking query"
+        end
+
+        context "without index name and without space before the opening bracket" do
+          let(:alter_table_action) { "ADD INDEX #{using_option}(`t_now` ASC)" }
+          it_behaves_like "a parser parsing a nonbreaking query"
+        end
+
+        context "with hash" do
+          let(:using_option) { "USING hash" }
+          it_behaves_like "a parser parsing a nonbreaking query"
+        end
+      end
+      context "with normal key options" do
+        let(:alter_table_action) { "ADD INDEX (`t_now` ASC)#{normal_key_options}" }
+        it_behaves_like "test normal key options", "a parser parsing a nonbreaking query"
+      end
+    end
+    context "fulltext or spatial" do
+      let(:action) { :add_index }
+      shared_examples "test all permutations" do |examples|
+        context "key_or_index" do
+          shared_examples "a parser parsing a nonbreaking query with key options" do
+            let(:alter_table_action) { "ADD #{fulltext_or_spatial} #{key_or_index} #{key_name} (test_column)#{key_options}" }
+            context "no key option" do
+              it_behaves_like "a parser parsing a nonbreaking query" do
+                let(:key_options) { "" }
+              end
+            end
+            context "key_block_size" do
+              it_behaves_like "a parser parsing a nonbreaking query" do
+                let(:key_options) { " KEY_BLOCK_SIZE 2048" }
+              end
+            end
+            context "comment" do
+              it_behaves_like "a parser parsing a nonbreaking query" do
+                let(:key_options) { " COMMENT 'Hello World!'" }
+              end
+            end
+            context "comment and key_block_size" do
+              it_behaves_like "a parser parsing a nonbreaking query" do
+                let(:key_options) { " KEY_BLOCK_SIZE = 1024 COMMENT 'Hello World!'" }
+              end
+            end
+          end
+          shared_examples "a parser parsing a nonbreaking query with key options fulltext" do
+            it_behaves_like "a parser parsing a nonbreaking query with key options"
+            let(:alter_table_action) { "ADD #{fulltext_or_spatial} #{key_or_index} #{key_name} (test_column)#{key_options}" }
+            context "with parser" do
+              it_behaves_like "a parser parsing a nonbreaking query" do
+                let(:key_options) { " WITH PARSER test_parser" }
+              end
+            end
+          end
+          shared_examples "a parser parsing a query with either key or index" do |*examples|
+            let(:alter_table_action) { "ADD #{fulltext_or_spatial} #{key_or_index} #{key_name} (test_column)" }
+            context "no key name" do
+              it_behaves_like *examples do
+                let(:key_name) { "" }
+              end
+            end
+            context "simple key name" do
+              it_behaves_like *examples do
+                let(:key_name) { "test_key" }
+              end
+            end
+            context "quoted key name" do
+              it_behaves_like *examples do
+                let(:key_name) { "`test_key`" }
+              end
+            end
+          end
+          it_behaves_like "test optional key or index", "a parser parsing a query with either key or index", examples
+        end
+      end
+      context "with fulltext" do
+        it_behaves_like "test all permutations",  "a parser parsing a nonbreaking query with key options fulltext" do
+          let(:fulltext_or_spatial) { "FULLTEXT" }
+        end
+      end
+      context "with spatial" do
+        it_behaves_like "test all permutations",  "a parser parsing a nonbreaking query with key options" do
+          let(:fulltext_or_spatial) { "SPATIAL" }
+        end
+      end
+    end
+    context "check constraint" do
+      let(:action) { :add_check_constraint }
+      let(:alter_table_action) { "ADD#{constraint_keyword} CHECK (#{constraint_expr})" }
+      shared_examples "test constraint expr" do
+        context "with constraint expr" do
+          it_behaves_like "test constraint keyword", "a parser parsing a nonbreaking query" do
+            let(:constraint_expr) { "P_Id>0 AND City='Sandnes'" }
+          end
+        end
+      end
+
+      context "test all" do
+        it_behaves_like "test constraint expr"
+      end
+    end
+    context "unique constraint" do
+      let(:action) { :add_unique_constraint }
+      let(:alter_table_action) { "ADD#{constraint_keyword} UNIQUE#{key_or_index}#{key_name}#{using_option} (#{key_list})#{normal_key_options}" }
+
+      it_behaves_like "test constraint keyword", "test optional key or index",
+                      "test key name", "test using option", "test key list",
+                      "test normal key options",
+#                      "a debug parser"
+                      "a parser parsing a nonbreaking query"
+    end
+    context "primary key constraint" do
+      let(:alter_table_action) { "ADD#{constraint_keyword} PRIMARY KEY#{key_name}#{using_option} (#{key_list})#{normal_key_options}" }
+      let(:action) { :add_primary_key_constraint }
+      let(:action_hash) {
+        {
+          action: action,
+          keys: expected_key_list,
+          query: alter_table_action,
+        }
+      }
+
+      it_behaves_like "test constraint keyword",
+                      "test key name", "test using option", "test key list",
+                      "test normal key options",
+#                      "a debug parser"
+                      "a parser parsing a single action alter table query"
+    end
+    context "enable keys" do
+      let(:alter_table_action) { "ENABLE KEYS" }
+      let(:action) { :enable_keys }
+      let(:action_hash) {
+        {
+          action: action,
+          support_level: :nonbreaking,
+          query: alter_table_action,
+        }
+      }
+    end
+    context "drop primary key" do
+      let(:alter_table_action) { "DROP PRIMARY KEY" }
+      let(:action) { :drop_primary_key }
+
+      it_behaves_like "a parser parsing a breaking query"
+    end
+    context "drop foreign key" do
+      let(:alter_table_action) { "DROP FOREIGN KEY#{field_ident}" }
+      let(:action) { :drop_foreign_key }
+
+      it_behaves_like "test field identifier", "a parser parsing a nonbreaking query"
+    end
+    context "drop key or index" do
+      let(:alter_table_action) { "DROP#{key_or_index}#{field_ident}" }
+      let(:action) { "drop_#{key_or_index.strip.downcase}".to_sym }
+
+      it_behaves_like "test key or index", "test field identifier", "a parser parsing a nonbreaking query"
+    end
   end
 end