scheman 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c96927177dfbde154defcf9c902c953c60a580a
-  data.tar.gz: 51e98f13cdf9ea43eec4a515be4b883ab855b880
+  metadata.gz: 3e73fa1b30a5a2616d7b7a44c8b3b2dfd750e3d9
+  data.tar.gz: dba7df4899f8acaf89b4f55bd611403c773e0768
 SHA512:
-  metadata.gz: 09fb8220340760be61f9a6ad057313604657dc4425fb97bc0ac10bf41c05295e7800da6a2ae0bfb8857dc407393a3edd5c6892b5af81ffb783a8c69acdf14ffe
-  data.tar.gz: a1a90f9957eec8d37e83a367d5d3417016a1032143702c3e6c26834cbf3b678797f289b855c757faf05d0fc14923a986ff6606ea7c5b262454e7e686faee5d3b
+  metadata.gz: 4830bd819919bfb956a0b17a1068300071ba6e1974ac09ee4e9cfd03980043fa80630214f742f91218e8ec107843244d3fd55ba0396d0fe653c1322c4b7adb6d
+  data.tar.gz: 84543f84774b5ca849df3689d3738b1b89465d14a22ca2d30e32a6e35b4ea17155a71e79073f01ae4b45976f9d4cab8cdb3764d79d594fbfd98ad476df56048f

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.0.2
+* Support ADD INDEX
+* Support DROP INDEX
+* Detects altered column
+
+## 0.0.1
+* 1st Release

data/README.md

@@ -1,30 +1,32 @@
 # Scheman
-Manage database schema based on schema definition file.
+SQL schema parser.
 
 ## Usage
-Creates Diff with 2 schema files and logs out their diff.
+Create diff from 2 schema files.
 
 ```ruby
+require "scheman"
+
 before = <<-SQL
 CREATE TABLE `table1` (
-  `column1` INTEGER NOT NULL AUTO INCREMENT,
-  PRIMARY KEY (`column1`)
+  `column1` INTEGER(11) PRIMARY KEY NOT NULL AUTO INCREMENT
 );
 
 CREATE TABLE `table2` (
-  `column1` INTEGER NOT NULL AUTO INCREMENT,
+  `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
   PRIMARY KEY (`column1`)
 );
 SQL
 
 after = <<-SQL
 CREATE TABLE `table1` (
+  `column1` CHAR(11) NOT NULL AUTO INCREMENT,
   `column2` VARCHAR(255) NOT NULL,
-  PRIMARY KEY (`column1`)
+  PRIMARY KEY (`column2`)
 );
 
 CREATE TABLE `table3` (
-  `column1` INTEGER NOT NULL AUTO INCREMENT,
+  `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
   PRIMARY KEY (`column1`)
 );
 SQL
@@ -40,13 +42,14 @@ BEGIN;
 SET foreign_key_checks=0;
 
 CREATE TABLE `table3` (
-  `column1` INTEGER NOT NULL AUTO INCREMENT,
+  `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
   PRIMARY KEY (`column1`)
 );
 
-ALTER TABLE `table1` ADD COLUMN `column2` VARCHAR(255) NOT NULL;
-
-ALTER TABLE `table1` DROP COLUMN `column1`;
+ALTER TABLE `table1` ADD COLUMN `column2` VARCHAR(255) NOT NULL,
+  CHANGE COLUMN `column1` CHAR(11) NOT NULL AUTO INCREMENT,
+  DROP PRIMARY KEY,
+  ADD PRIMARY KEY `column2`;
 
 DROP TABLE `table2`;
 

data/lib/scheman/diff.rb

@@ -34,10 +34,14 @@ module Scheman
 
     private
 
-    # TODO
     # @return [Array<Hash>] ALTER TABLE statements we need to apply
     def alter_tables
-      after_schema.tables.inject([]) do |result, after_table|
+      drop_fields + add_fields + alter_fields + drop_indices + add_indices
+    end
+
+    # @return [Array<Hash>] ALTER TABLE statements for adding new fields
+    def add_fields
+      after_schema.tables.each_with_object([]) do |after_table, result|
         if before_table = before_schema.tables_indexed_by_name[after_table.name]
           after_table.fields.each do |after_field|
             unless before_table.fields_indexed_by_name[after_field.name]
@@ -46,7 +50,14 @@ module Scheman
               }
             end
           end
+        end
+      end
+    end
 
+    # @return [Array<Hash>] ALTER TABLE statements for dropping fields
+    def drop_fields
+      after_schema.tables.each_with_object([]) do |after_table, result|
+        if before_table = before_schema.tables_indexed_by_name[after_table.name]
           before_table.fields.each do |before_field|
             unless after_table.fields_indexed_by_name[before_field.name]
               result << {
@@ -55,7 +66,47 @@ module Scheman
             end
           end
         end
-        result
+      end
+    end
+
+    # @return [Array<Hash>] ALTER TABLE statements for altering fields
+    def alter_fields
+      after_schema.tables.each_with_object([]) do |after_table, result|
+        if before_table = before_schema.tables_indexed_by_name[after_table.name]
+          after_table.fields.each do |after_field|
+            if before_field = before_table.fields_indexed_by_name[after_field.name]
+              result << {
+                alter_field: after_field.to_hash.merge(table_name: after_table.name),
+              }
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Array<Hash>] ALTER TABLE statements for adding indices
+    def add_indices
+      after_schema.tables.each_with_object([]) do |after_table, result|
+        if before_table = before_schema.tables_indexed_by_name[after_table.name]
+          (after_table.indices - before_table.indices).each do |index|
+            result << {
+              add_index: index.merge(table_name: after_table.name),
+            }
+          end
+        end
+      end
+    end
+
+    # @return [Array<Hash>] ALTER TABLE statements for dropping indices
+    def drop_indices
+      after_schema.tables.each_with_object([]) do |after_table, result|
+        if before_table = before_schema.tables_indexed_by_name[after_table.name]
+          (before_table.indices - after_table.indices).each do |index|
+            result << {
+              drop_index: index.merge(table_name: after_table.name),
+            }
+          end
+        end
       end
     end
 

data/lib/scheman/parsers/mysql.rb

@@ -266,12 +266,7 @@ module Scheman
             auto_increment_qualifier |
             character_set_qualifier |
             collate_qualifier |
-            unique_key_qualifier |
-            key_qualifier
-        end
-
-        rule(:key_qualifier) do
-          word_index.as(:key_qualifier)
+            unique_key_qualifier
         end
 
         rule(:unique_key_qualifier) do
@@ -287,7 +282,7 @@ module Scheman
         end
 
         rule(:primary_key_qualifier) do
-          case_insensitive_str("primary key").as(:primary_key_qualifier)
+          (word_index | case_insensitive_str("primary key")).as(:primary_key_qualifier)
         end
 
         rule(:null_qualifier) do

data/lib/scheman/schema.rb

@@ -20,7 +20,6 @@ module Scheman
       @tables_indexed_by_name ||= tables.index_by(&:name)
     end
 
-    # TODO: We might want to calculate DROP TABLE and ALTER TABLE against to created tables
     # @return [Array<Scheman::Schema::Table>] All tables to be created after applying this schema
     def tables
       @tables ||= create_tables.map do |create_table|
@@ -43,22 +42,52 @@ module Scheman
         @table[:name]
       end
 
-      # @return [Array]
+      # @return [Array<Field>]
       def fields
         @table[:fields].map do |field|
-          Field.new(field[:field])
+          Field.new(field: field[:field], table: self)
         end
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Field}]
       def fields_indexed_by_name
         @fields_indexed_by_name ||= fields.index_by(&:name)
       end
+
+      # @return [Array<Hash>]
+      def indices
+        @indices ||= indices_from_definitions + indices_from_fields
+      end
+
+      private
+
+      def indices_from_definitions
+        @table[:indices].map do |hash|
+          hash[:index]
+        end
+      end
+
+      # @return [Array<Hash>]
+      def indices_from_fields
+        fields.map(&:index).compact
+      end
     end
 
     class Field
-      def initialize(field)
+      def initialize(field: nil, table: nil)
         @field = field
+        @table = table
+      end
+
+      # @note Overridden
+      # @return [true, false]
+      def ==(field)
+        type == field.type && size == field.size && qualifiers == field.qualifiers
+      end
+
+      # @return [Hash]
+      def to_hash
+        @field.merge(qualifiers: qualifiers)
       end
 
       # @return [String]
@@ -66,9 +95,47 @@ module Scheman
         @field[:name]
       end
 
-      # @return [Hash]
-      def to_hash
-        @field
+      # @return [String] Lower-cased type name
+      # @example
+      #   "varchar"
+      def type
+        @field[:type]
+      end
+
+      # @note Size can be 2 values but not supported yet
+      # @return [String, nil]
+      def size
+        field[:size]
+      end
+
+      # @return [Array<Hash>] Sorted qualifiers, without index-related types
+      def qualifiers
+        @qualifiers ||= @field[:qualifiers].reject do |qualifier|
+          %w[primary_key unique_key].include?(qualifier[:qualifier][:type])
+        end
+      end
+
+      # @return [Hash] Index defined as a field qualifier
+      def index
+        @field[:qualifiers].find do |qualifier|
+          case qualifier[:qualifier][:type]
+          when "primary_key"
+            break {
+              column: name,
+              name: nil,
+              primary: true,
+              type: nil,
+            }
+          when "unique_key"
+            break {
+              column: name,
+              name: nil,
+              primary: nil,
+              type: nil,
+              unique: true,
+            }
+          end
+        end
       end
     end
   end

data/lib/scheman/version.rb

@@ -1,3 +1,3 @@
 module Scheman
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/scheman/views/mysql.rb

@@ -67,6 +67,18 @@ module Scheman
         rule(drop_field: subtree(:drop_field)) do
           DropField.new(drop_field)
         end
+
+        rule(alter_field: subtree(:alter_field)) do
+          AlterField.new(alter_field)
+        end
+
+        rule(add_index: subtree(:add_index)) do
+          AddIndex.new(add_index)
+        end
+
+        rule(drop_index: subtree(:drop_index)) do
+          DropIndex.new(drop_index)
+        end
       end
 
       class Node
@@ -81,7 +93,18 @@ module Scheman
         end
       end
 
-      class AlterTables < Statements
+      class AlterTables < Node
+        def to_s
+          alter_tables.join("\n\n")
+        end
+
+        private
+
+        def alter_tables
+          @element.group_by(&:table_name).map do |table_name, alter_tables|
+            %<ALTER TABLE `#{table_name}` #{alter_tables.join(",\n  ")};>
+          end.sort
+        end
       end
 
       class DropTables < Statements
@@ -103,34 +126,38 @@ module Scheman
       end
 
       class AlterTable < Node
-        def to_s
-          "TODO"
+        def table_name
+          @element[:table_name]
         end
       end
 
-      class AlterField < Node
+      class AlterField < AlterTable
+        def to_s
+          "CHANGE COLUMN #{field_definition}"
+        end
+
         private
 
-        def table_name
-          @element[:table_name]
+        def field_definition
+          Field.new(@element)
         end
       end
 
-      class AddField < AlterField
+      class AddField < AlterTable
         def to_s
-          "ALTER TABLE `#{table_name}` ADD COLUMN #{field};"
+          "ADD COLUMN #{field_definition}"
         end
 
         private
 
-        def field
+        def field_definition
           Field.new(@element)
         end
       end
 
-      class DropField < AlterField
+      class DropField < AlterTable
         def to_s
-          "ALTER TABLE `#{table_name}` DROP COLUMN `#{field_name}`;"
+          "DROP COLUMN `#{field_name}`"
         end
 
         private
@@ -140,6 +167,61 @@ module Scheman
         end
       end
 
+      class AddIndex < AlterTable
+        def to_s
+          "ADD #{index_definition_name} #{index}"
+        end
+
+        private
+
+        def index_name
+          @element[:name]
+        end
+
+        def index_definition_name
+          case
+          when @element[:primary]
+            "PRIMARY KEY"
+          when @element[:unique]
+            "UNIQUE KEY"
+          else
+            "KEY"
+          end
+        end
+
+        def index_type
+          @element[:type]
+        end
+
+        def index_column
+          @element[:column]
+        end
+
+        def index
+          str = ""
+          str << "#{index_name} " if index_name
+          str << "#{index_type} " if index_type
+          str << "`#{index_column}`"
+        end
+      end
+
+      class DropIndex < AlterTable
+        def to_s
+          if @element[:primary]
+            "DROP PRIMARY KEY"
+          else
+            "DROP INDEX `#{index_name}`"
+          end
+        end
+
+        private
+
+        # TODO How to refer to an automatically named index name?
+        def index_name
+          @element[:name] || @element[:column]
+        end
+      end
+
       class CreateTable < Node
         def to_s
           str = ""

data/scheman.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.version       = Scheman::VERSION
   spec.authors       = ["Ryo Nakamura"]
   spec.email         = ["r7kamura@gmail.com"]
-  spec.summary       = "Manage database schema based on schema definition file."
+  spec.summary       = "SQL schema parser."
   spec.homepage      = "https://github.com/r7kamura/scheman"
   spec.license       = "MIT"
 

data/spec/scheman/diff_spec.rb

@@ -20,12 +20,11 @@ describe Scheman::Diff do
   let(:before_schema) do
     <<-EOS.strip_heredoc
       CREATE TABLE `table1` (
-        `column1` INTEGER NOT NULL AUTO INCREMENT,
-        PRIMARY KEY (`column1`)
+        `column1` INTEGER(11) PRIMARY KEY NOT NULL AUTO INCREMENT
       );
 
       CREATE TABLE `table2` (
-        `column1` INTEGER NOT NULL AUTO INCREMENT,
+        `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
         PRIMARY KEY (`column1`)
       );
     EOS
@@ -34,12 +33,13 @@ describe Scheman::Diff do
   let(:after_schema) do
     <<-EOS.strip_heredoc
       CREATE TABLE `table1` (
+        `column1` CHAR(11) NOT NULL AUTO INCREMENT,
         `column2` VARCHAR(255) NOT NULL,
-        PRIMARY KEY (`column1`)
+        PRIMARY KEY (`column2`)
       );
 
       CREATE TABLE `table3` (
-        `column1` INTEGER NOT NULL AUTO INCREMENT,
+        `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
         PRIMARY KEY (`column1`)
       );
     EOS
@@ -57,13 +57,14 @@ describe Scheman::Diff do
         SET foreign_key_checks=0;
 
         CREATE TABLE `table3` (
-          `column1` INTEGER NOT NULL AUTO INCREMENT,
+          `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
           PRIMARY KEY (`column1`)
         );
 
-        ALTER TABLE `table1` ADD COLUMN `column2` VARCHAR(255) NOT NULL;
-
-        ALTER TABLE `table1` DROP COLUMN `column1`;
+        ALTER TABLE `table1` ADD COLUMN `column2` VARCHAR(255) NOT NULL,
+          CHANGE COLUMN `column1` CHAR(11) NOT NULL AUTO INCREMENT,
+          DROP PRIMARY KEY,
+          ADD PRIMARY KEY `column2`;
 
         DROP TABLE `table2`;
 

data/spec/scheman/parsers/mysql_spec.rb

@@ -29,7 +29,7 @@ describe Scheman::Parsers::Mysql do
           CREATE DATABASE database_name;
 
           CREATE TABLE `table1` (
-            `column1` INTEGER NOT NULL AUTO INCREMENT,
+            `column1` INTEGER(11) NOT NULL AUTO INCREMENT,
             `column2` VARCHAR(255) NOT NULL,
             PRIMARY KEY (`column1`)
           );
@@ -55,7 +55,7 @@ describe Scheman::Parsers::Mysql do
                   field: {
                     name: "column1",
                     type: "integer",
-                    values: [],
+                    values: ["11"],
                     qualifiers: [
                       {
                         qualifier: {
@@ -161,6 +161,26 @@ describe Scheman::Parsers::Mysql do
       end
     end
 
+    context "with KEY field qualifier" do
+      let(:str) do
+        "CREATE TABLE `table1` (`column1` INTEGER KEY);"
+      end
+
+      it "succeeds in parse" do
+        subject[0][:create_table][:fields][0][:field][:qualifiers][0][:qualifier][:type].should == "primary_key"
+      end
+    end
+
+    context "with INDEX field qualifier" do
+      let(:str) do
+        "CREATE TABLE `table1` (`column1` INTEGER INDEX);"
+      end
+
+      it "succeeds in parse" do
+        subject[0][:create_table][:fields][0][:field][:qualifiers][0][:qualifier][:type].should == "primary_key"
+      end
+    end
+
     context "with UNSIGNED field type qualifier" do
       let(:str) do
         "CREATE TABLE `table1` (`column1` INTEGER UNSIGNED);"
@@ -221,26 +241,6 @@ describe Scheman::Parsers::Mysql do
       end
     end
 
-    context "with KEY field qualifier" do
-      let(:str) do
-        "CREATE TABLE `table1` (`column1` INTEGER KEY);"
-      end
-
-      it "succeeds in parse" do
-        subject[0][:create_table][:fields][0][:field][:qualifiers][0][:qualifier][:type].should == "key"
-      end
-    end
-
-    context "with INDEX field qualifier" do
-      let(:str) do
-        "CREATE TABLE `table1` (`column1` INTEGER INDEX);"
-      end
-
-      it "succeeds in parse" do
-        subject[0][:create_table][:fields][0][:field][:qualifiers][0][:qualifier][:type].should == "key"
-      end
-    end
-
     context "with PRIMARY KEY" do
       let(:str) do
         <<-EOS.strip_heredoc

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scheman
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-06 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -102,6 +102,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -143,7 +144,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Manage database schema based on schema definition file.
+summary: SQL schema parser.
 test_files:
 - spec/scheman/diff_spec.rb
 - spec/scheman/parsers/mysql_spec.rb