activefacts 1.6.0 → 1.7.1

data/lib/activefacts/generate/rails/schema.rb

@@ -1,216 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate a Rails-friendly schema.rb from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2012 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/persistence'
-require 'activefacts/mapping/rails'
-
-module ActiveFacts
-  module Generate
-    module Rails
-      # Generate a Rails-friendly schema for the vocabulary
-      # Invoke as
-      #   afgen --rails/schema[=options] <file>.cql
-      class SchemaRb
-      private
-	include Persistence
-
-	def initialize(vocabulary, *options)
-	  @vocabulary = vocabulary
-	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-	  help if options.include? "help"
-	  @exclude_fks = options.include? "exclude_fks"
-	  @include_comments = options.include? "include_comments"
-	  @closed_world = options.include? "closed_world"
-	end
-
-	def help
-	  @helping = true
-	  warn %Q{Options for --rails/schema:
-	exclude_fks		Don't generate foreign key definitions for use with Rails 4 or the foreigner gem
-	include_comments	Generate a comment for each column showing the absorption path
-	closed_world		Set this if your DBMS only allows one null in a unique index (MS SQL)
-}
-	end
-
-	def warn *a
-	  $stderr.puts *a
-	end
-
-	def puts s
-	  @out.puts s
-	end
-
-      public
-
-	# We sort the columns here, not in the persistence layer, because it affects
-	# the ordering of columns in an index :-(.
-	def sorted_columns table, pk, fk_columns
-	  table.columns.sort_by do |column|
-	    [ # Emit columns alphabetically, but PK first, then FKs, then others
-	      case
-	      when i = pk.index(column)
-		i
-	      when fk_columns.include?(column)
-		pk.size+1
-	      else
-		pk.size+2
-	      end,
-	      column.rails_name
-	    ]
-	  end
-	end
-
-	def generate_column table, pk, column
-	  name = column.rails_name
-	  type, params, constraints = *column.type
-	  length = params[:length]
-	  length &&= length.to_i
-	  scale = params[:scale]
-	  scale &&= scale.to_i
-	  rails_type, length = *column.rails_type
- 
-	  length_name = rails_type == 'decimal' ? 'precision' : 'limit'
-	  length_option = length ? ", :#{length_name} => #{length}" : ''
-	  scale_option = scale ? ", :scale => #{scale}" : ''
-
-	  comment = column.comment
-	  null_option = ", :null => #{!column.is_mandatory}"
-	  if pk.size == 1 && pk[0] == column
-	    case rails_type
-	    when 'serial'
-	      rails_type = "primary_key"
-	    when 'uuid'
-	      rails_type = "uuid, :default => 'gen_random_uuid()', :primary_key => true"
-	    end
-	  else
-	    case rails_type
-	    when 'serial'
-	      rails_type = 'integer'	    # An integer foreign key
-	    end
-	  end
-
-	  (@include_comments ? ["    \# #{comment}"] : []) +
-	  [
-	    %Q{    t.column "#{name}", :#{rails_type}#{length_option}#{scale_option}#{null_option}}
-	  ]
-	end
-
-	def generate_columns table, pk, fk_columns
-	  sc = sorted_columns(table, pk, fk_columns)
-	  lines = sc.map do |column|
-	    generate_column table, pk, column
-	  end
-	  lines.flatten
-	end
-
-	def generate_table table, foreign_keys
-	  ar_table_name = table.rails_name
-
-	  pk = table.identifier_columns
-	  if pk[0].is_auto_assigned
-	    identity_column = pk[0]
-	    warn "Warning: redundant column(s) after #{identity_column.name} in primary key of #{ar_table_name}" if pk.size > 1
-	  end
-
-	  # Get the list of references that give rise to foreign keys:
-	  fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-
-	  # Get the list of columns that embody the foreign keys:
-	  fk_columns = table.columns.select do |column|
-	    column.references[0].is_simple_reference
-	  end
-
-	  # Detect if this table is a join table.
-	  # Join tables have multi-part primary keys that are made up only of foreign keys
-	  is_join_table = pk.length > 1 and
-	    !pk.detect do |pk_column|
-	      !fk_columns.include?(pk_column)
-	    end
-	  warn "Warning: #{table.name} has a multi-part primary key" if pk.length > 1 and !is_join_table
-
-	  puts %Q{  create_table "#{ar_table_name}", :id => false, :force => true do |t|}
-
-	  columns = generate_columns table, pk, fk_columns
-
-	  unless @exclude_fks
-	    table.foreign_keys.each do |fk|
-	      from_columns = fk.from_columns.map{|column| column.rails_name}
-	      to_columns = fk.to_columns.map{|column| column.rails_name}
-
-	      foreign_keys.concat(
-		if (from_columns.length == 1)
-		  index_name = Persistence.rails_name_trunc('index_'+fk.from.rails_name+'_on_'+from_columns[0])
-		  [
-		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :on_delete => :cascade"
-		  ]+
-		  Array(
-		    # Index it non-uniquely only if it's not unique already:
-		    fk.jump_reference.to_role.unique ? nil :
-		      "    add_index :#{fk.from.rails_name}, [:#{from_columns[0]}], :unique => false, :name => :#{index_name}"
-		  )
-		else
-		  # This probably isn't going to work without Dr Nic's CPK gem:
-		  [
-		    "    add_foreign_key :#{fk.to.rails_name}, :#{fk.from.rails_name}, :column => [:#{from_columns.join(':, ')}], :primary_key => [:#{to_columns.join(':, ')}], :on_delete => :cascade"
-		  ]
-		end
-	      )
-	    end
-	  end
-
-	  indices = table.indices
-	  index_text = []
-	  indices.each do |index|
-	    next if index.is_primary && index.columns.size == 1	  # We've handled this already
-
-	    index_name = index.rails_name
-
-	    unique = !index.columns.detect{|column| !column.is_mandatory} and !@closed_world
-	    index_text << %Q{  add_index "#{ar_table_name}", ["#{index.columns.map{|c| c.rails_name}*'", "'}"], :name => :#{index_name}#{
-	      unique ? ", :unique => true" : ''
-	    }}
-	  end
-
-	  puts columns.join("\n")
-	  puts "  end\n\n"
-
-	  puts index_text.join("\n")
-	  puts "\n" unless index_text.empty?
-	end
-
-	def generate(out = $>)      #:nodoc:
-	  return if @helping
-	  @out = out
-
-	  foreign_keys = []
-
-	  # If we get index names that need to be truncated, add a counter to ensure uniqueness
-	  dup_id = 0
-
-	  puts "#\n# schema.rb auto-generated using ActiveFacts for #{@vocabulary.name} on #{Date.today}\n#\n\n"
-	  puts "ActiveRecord::Base.logger = Logger.new(STDOUT)\n"
-	  puts "ActiveRecord::Schema.define(:version => #{Time.now.strftime('%Y%m%d%H%M%S')}) do"
-	  puts "  enable_extension 'pgcrypto' unless extension_enabled?('pgcrypto')\n"
-
-	  @vocabulary.tables.each do |table|
-	    generate_table table, foreign_keys
-	  end
-
-	  unless @exclude_fks
-	    puts '  unless ENV["EXCLUDE_FKS"]'
-	    puts foreign_keys.join("\n")
-	    puts '  end'
-	  end
-	  puts "end"
-	end
-
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('rails/schema', ActiveFacts::Generate::Rails::SchemaRb)

data/lib/activefacts/generate/records.rb

@@ -1,46 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate text output (verbalise the meta-vocabulary) for ActiveFacts vocabularies.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --text <file>.cql
-    class RECORDS
-    private
-      def initialize(vocabulary)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-      end
-
-    public
-      def generate(out = $>)
-        # Extract the list of tables in the relational mapping of the metamodel
-        # We'll use the columns too.
-        @metamodel = ActiveFacts::CQL::Compiler.new.compile_file "examples/CQL/Metamodel.cql"
-        tables = @metamodel.tables.sort_by{|t| t.name}
-
-        class_names = tables.map{|t| t.name.gsub(/\s/,'')}
-        # map{|t| ActiveFacts::Metamodel.const_get(t.name.gsub(/\s/,''))}
-
-        tables.zip(class_names).each do |table, class_name|
-          instance_index = @vocabulary.constellation.send(class_name)
-          debugger
-          next if instance_index.empty?
-          out.puts "#{table.name}(#{table.columns.map{|c| c.name}*', '})"
-          debugger
-          instance_index.each do |key, value|
-            out.puts "\t"+value.verbalise
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('records', ActiveFacts::Generate::RECORDS)

data/lib/activefacts/generate/ruby.rb

@@ -1,133 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate Ruby classes for the ActiveFacts API from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts'
-require 'activefacts/vocabulary'
-require 'activefacts/generate/helpers/oo'
-require 'activefacts/generate/traits/ruby'
-require 'activefacts/mapping/rails'
-
-module ActiveFacts
-  module Generate
-
-    # Generate Ruby module containing classes for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --ruby[=options] <file>.cql
-    # Options are comma or space separated:
-    # * help list available options
-    # * sql Emit the sql mapping for tables/columns (REVISIT: not functional at present)
-    class RUBY < Helpers::OO
-    private
-
-      def set_option(option)
-        @mapping = false
-        case option
-        when 'help', '?'
-          $stderr.puts "Usage:\t\tafgen --ruby[=option,option] input_file.cql\n"+
-              "\t\tmapping={sql|rails}\tEmit data to enable mappings to SQL or to Rails"
-          exit 0
-        when /mapping=(.*)/
-          @mapping = $1
-          @vocabulary.tables
-        else super
-        end
-      end
-
-      def vocabulary_start
-        puts @vocabulary.prelude
-      end
-
-      def vocabulary_end
-        puts @vocabulary.finale
-      end
-
-      def emit_mapping o
-        case @mapping
-        when 'sql'
-          puts "    table"
-        when 'rails'
-          puts "    table :#{o.rails_name}"
-        end
-      end
-
-      def data_type_dump(o)
-	value_type_dump(o, o.name, {}) if o.all_role.size > 0
-      end
-
-      def value_type_dump(o, super_type_name, facets)
-	puts o.ruby_definition
-      end
-
-      def subtype_dump(o, supertypes, pi = nil)
-        primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
-        secondary_supertypes = o.supertypes-[primary_supertype]
-
-        puts "  class #{o.name.gsub(/ /,'')} < #{ primary_supertype.name.gsub(/ /,'') }"
-        puts "    identified_by #{identified_by(o, pi)}" if pi
-        puts "    supertypes "+secondary_supertypes.map{|st| st.name.gsub(/ /,'')}*", " if secondary_supertypes.size > 0
-        emit_mapping(o) if o.is_table
-        fact_roles_dump(o.fact_type) if o.fact_type
-        roles_dump(o)
-        puts "  end\n\n"
-        pi.ordered_dumped! if pi
-      end
-
-      def non_subtype_dump(o, pi)
-        puts "  class #{o.name.gsub(/ /,'')}"
-
-        # We want to name the absorption role only when it's absorbed along its single identifying role.
-        puts "    identified_by #{identified_by(o, pi)}"
-        emit_mapping o if o.is_table
-        fact_roles_dump(o.fact_type) if o.fact_type
-        roles_dump(o)
-        puts "  end\n\n"
-        pi.ordered_dumped!
-      end
-
-      # Dump one fact type.
-      def fact_type_dump(fact_type, name)
-        return if skip_fact_type(fact_type)
-        o = fact_type.entity_type
-
-        primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
-        secondary_supertypes = o.supertypes-[primary_supertype]
-
-        # Get the preferred identifier, but don't emit it unless it's different from the primary supertype's:
-        pi = o.preferred_identifier
-        pi = nil if pi && primary_supertype && primary_supertype.preferred_identifier == pi
-
-        puts "  class #{name.gsub(/ /,'')}" +
-          (primary_supertype ? " < "+primary_supertype.name.gsub(/ /,'') : "") +
-          "\n" +
-          secondary_supertypes.map{|sst| "    supertype :#{sst.name.gsub(/ /,'_')}"}*"\n" +
-          (pi ? "    identified_by #{identified_by(o, pi)}" : "")
-        emit_mapping o if o.is_table
-        fact_roles_dump(fact_type)
-        roles_dump(o)
-        puts "  end\n\n"
-
-        fact_type.ordered_dumped!
-      end
-
-      def identified_by_roles_and_facts(entity_type, identifying_role_refs, identifying_facts)
-        identifying_role_refs.map{|role_ref|
-            ":"+role_ref.role.preferred_role_name(entity_type)
-          }*", "
-      end
-
-      def unary_dump(role, role_name)
-        puts "    maybe :"+role_name
-      end
-
-      def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, counterpart_role_name = nil, counterpart_method_name = nil)
-	puts role.as_binary(role_name, role_player, mandatory, one_to_one, readings, counterpart_role_name, counterpart_method_name)
-      end
-
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('ruby', ActiveFacts::Generate::RUBY)

data/lib/activefacts/generate/sql/mysql.rb

@@ -1,280 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate SQL for MySQL from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Daniel Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    module SQL #:nodoc:
-      # Generate SQL for MySQL for an ActiveFacts vocabulary.
-      # Invoke as
-      #   afgen --sql/mysql[=options] <file>.cql
-      # Options are comma or space separated:
-      # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
-      class MYSQL
-      private
-        include Persistence
-        ColumnNameMax = 63
-        DefaultCharColLength = 63
-
-        RESERVED_WORDS = %w{
-          ACCESSIBLE ADD ALL ALTER ANALYZE AND AS ASC ASENSITIVE
-          BEFORE BETWEEN BIGINT BINARY BLOB BOTH BY CALL CASCADE
-          CASE CHANGE CHAR CHARACTER CHECK COLLATE COLUMN CONNECTION
-          CONDITION CONSTRAINT CONTINUE CONVERT CREATE CROSS
-          CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER
-          CURSOR DATABASE DATABASES DAY_HOUR DAY_MICROSECOND
-          DAY_MINUTE DAY_SECOND DEC DECIMAL DECLARE DEFAULT DELAYED
-          DELETE DESC DESCRIBE DETERMINISTIC DISTINCT DISTINCTROW
-          DIV DOUBLE DROP DUAL EACH ELSE ELSEIF ENCLOSED ESCAPED
-          EXISTS EXIT EXPLAIN FALSE FETCH FLOAT FLOAT4 FLOAT8 FOR
-          FORCE FOREIGN FROM FULLTEXT GRANT GROUP HAVING HIGH_PRIORITY
-          HOUR_MICROSECOND HOUR_MINUTE HOUR_SECOND IF IGNORE IN
-          INDEX INFILE INNER INOUT INSENSITIVE INSERT INT INT1 INT2
-          INT3 INT4 INT8 INTEGER INTERVAL INTO IS ITERATE JOIN KEY
-          KEYS KILL LEADING LEAVE LEFT LIKE LIMIT LINEAR LINES LOAD
-          LOCALTIME LOCALTIMESTAMP LOCK LONG LONGBLOB LONGTEXT LOOP
-          LOW_PRIORITY MASTER_SSL_VERIFY_SERVER_CERT MATCH MEDIUMBLOB
-          MEDIUMINT MEDIUMTEXT MIDDLEINT MINUTE_MICROSECOND
-          MINUTE_SECOND MOD MODIFIES NATURAL NOT NO_WRITE_TO_BINLOG
-          NULL NUMERIC ON OPTIMIZE OPTION OPTIONALLY OR ORDER OUT
-          OUTER OUTFILE PRECISION PRIMARY PROCEDURE PURGE RANGE
-          READ READ_ONLY READS READ_WRITE READ_WRITE REAL REFERENCES
-          REGEXP RELEASE RENAME REPEAT REPLACE REQUIRE RESTRICT
-          RETURN REVOKE RIGHT RLIKE SCHEMA SCHEMAS SECOND_MICROSECOND
-          SELECT SENSITIVE SEPARATOR SET SHOW SMALLINT SPATIAL
-          SPECIFIC SQL SQL_BIG_RESULT SQL_CALC_FOUND_ROWS SQLEXCEPTION
-          SQL_SMALL_RESULT SQLSTATE SQLWARNING SSL STARTING
-          STRAIGHT_JOIN TABLE TERMINATED THEN TINYBLOB TINYINT
-          TINYTEXT TO TRAILING TRIGGER TRUE UNDO UNION UNIQUE UNLOCK
-          UNSIGNED UPDATE UPGRADE USAGE USE USING UTC_DATE UTC_TIME
-          UTC_TIMESTAMP VALUES VARBINARY VARCHAR VARCHARACTER VARYING
-          WHEN WHERE WHILE WITH WRITE XOR YEAR_MONTH ZEROFILL
-        }.inject({}){ |h,w| h[w] = true; h }
-
-        def initialize(vocabulary, *options)
-          @vocabulary = vocabulary
-          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-          @delay_fks = options.include? "delay_fks"
-        end
-
-        def puts s
-          @out.puts s
-        end
-
-        def go s
-          puts s + ";\n\n"
-        end
-
-        def escape s
-          # Escape SQL keywords and non-identifiers
-          s = s[0...120]
-          if s =~ /[^A-Za-z0-9_]/ || RESERVED_WORDS[s.upcase]
-            "`#{s}`"
-          else
-            s
-          end
-        end
-
-        # Return SQL type and (modified?) length for the passed base type
-        def normalise_type(type, length)
-          sql_type = case type
-            when /^Auto ?Counter$/
-              'int'
-
-            when /^Signed ?Integer$/,
-              /^Signed ?Small ?Integer$/
-              s = case
-                when length <= 8
-                  'tinyint'
-                when length <= 16
-                  'shortint'
-                when length <= 32
-                  'int'
-                else 'bigint'
-                end
-              length = nil
-              s
-
-            when /^Unsigned ?Integer$/,
-              /^Unsigned ?Small ?Integer$/,
-              /^Unsigned ?Tiny ?Integer$/
-              s = case
-                when length <= 8
-                  'tinyint unsigned'
-                when length <= 16
-                  'shortint unsigned'
-                when length <= 32
-                  'int unsigned'
-                else 'bigint'
-                end
-              length = nil
-              s
-
-            when /^Decimal$/
-                'decimal'
-
-            when /^Fixed ?Length ?Text$/, /^Char$/
-                length ||= DefaultCharColLength
-                "char"
-            when /^Variable ?Length ?Text$/, /^String$/
-                length ||= DefaultCharColLength
-                "varchar"
-            # There are several large length text types; If you need to store more than 65k chars, look at using MEDIUMTEXT or LONGTEXT
-            # CQL does not yet allow you to specify a length for LargeLengthText.
-            when /^Large ?Length ?Text$/, /^Text$/
-              'text'
-
-            when /^Date ?And ?Time$/, /^Date ?Time$/
-              'datetime'
-            when /^Date$/
-              'date'
-            when /^Time$/
-              'time'
-            when /^Auto ?Time ?Stamp$/
-              'timestamp'
-
-            when /^Money$/
-              'decimal'
-            # Warning: Max 65 kbytes. To use larger types, try MediumBlob (16mb) or LongBlob (4gb)
-            when /^Picture ?Raw ?Data$/, /^Image$/
-              'blob'
-            when /^Variable ?Length ?Raw ?Data$/, /^Blob$/
-              'blob'
-            # Assuming you only want a boolean out of this. Should we specify length instead?
-            when /^BIT$/
-              'bit'
-            else type # raise "SQL type unknown for standard type #{type}"
-            end
-          [sql_type, length]
-        end
-
-      public
-        def generate(out = $>)      #:nodoc:
-          @out = out
-          #go "CREATE SCHEMA #{@vocabulary.name}"
-
-          tables_emitted = {}
-          delayed_foreign_keys = []
-
-          @vocabulary.tables.each do |table|
-            puts "CREATE TABLE #{escape table.name.gsub(' ','')} ("
-
-            pk = table.identifier_columns
-            identity_column = pk[0] if pk[0].is_auto_assigned
-
-            fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-            fk_columns = table.columns.select do |column|
-              column.references[0].is_simple_reference
-            end
-
-            # We sort the columns here, not in the persistence layer, because it affects
-            # the ordering of columns in an index :-(.
-            columns = table.columns.sort_by { |column| column.name(nil) }.map do |column|
-              name = escape column.name("")
-              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
-              type, params, constraints = column.type
-              constraints = [] if (fk_columns.include?(column))  # Don't enforce VT constraints on FK columns
-              length = params[:length]
-              length &&= length.to_i
-              scale = params[:scale]
-              scale &&= scale.to_i
-              type, length = normalise_type(type, length)
-              sql_type = "#{type}#{
-                if !length
-                  ""
-                else
-                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
-                end
-                }"
-              identity = column == identity_column ? " AUTO_INCREMENT" : ""
-              null = (column.is_mandatory ? "NOT " : "") + "NULL"
-              check = check_clause(name, constraints)
-              comment = column.comment
-              [ "-- #{comment}", "#{name}#{padding}#{sql_type}#{identity} #{null}#{check}" ]
-            end.flatten
-
-            pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
-                pk.map{|column| escape column.name("")}*", " +
-                ")"
-
-            inline_fks = []
-            table.foreign_keys.each do |fk|
-              fk_text = "FOREIGN KEY (" +
-                fk.from_columns.map{|column| column.name}*", " +
-                ") REFERENCES #{escape fk.to.name.gsub(' ','')} (" +
-                fk.to_columns.map{|column| column.name}*", " +
-                ")"
-              if !@delay_fks and              # We don't want to delay all Fks
-                (tables_emitted[fk.to] or     # The target table has been emitted
-                fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
-                inline_fks << fk_text
-              else
-                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name.gsub(' ','')}\n\tADD " + fk_text)
-              end
-            end
-
-            indices = table.indices
-            inline_indices = []
-            delayed_indices = []
-            indices.each do |index|
-              next if index.over == table && index.is_primary   # Already did the primary keys
-              abbreviated_column_names = index.abbreviated_column_names*""
-              column_names = index.column_names
-              column_name_list = column_names.map{|n| escape(n)}*", "
-              inline_indices << "UNIQUE(#{column_name_list})"
-            end
-
-            tables_emitted[table] = true
-
-            puts("\t" + (columns + [pk_def] + inline_indices + inline_fks)*",\n\t")
-            go ")"
-            delayed_indices.each {|index_text|
-              go index_text
-            }
-          end
-
-          delayed_foreign_keys.each do |fk|
-            go fk
-          end
-        end
-
-      private
-        def sql_value(value)
-          value.is_literal_string ? sql_string(value.literal) : value.literal
-        end
-
-        def sql_string(str)
-          "'" + str.gsub(/'/,"''") + "'"
-        end
-
-        def check_clause(column_name, constraints)
-          return "" if constraints.empty?
-          # REVISIT: Merge all constraints (later; now just use the first)
-          " CHECK(" +
-            constraints[0].all_allowed_range_sorted.map do |ar|
-              vr = ar.value_range
-              min = vr.minimum_bound
-              max = vr.maximum_bound
-              if (min && max && max.value.literal == min.value.literal)
-                "#{column_name} = #{sql_value(min.value)}"
-              else
-                inequalities = [
-                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{sql_value(min.value)}",
-                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{sql_value(max.value)}"
-                ].compact
-                inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
-              end
-            end*" OR " +
-          ")"
-        end
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('sql/mysql', ActiveFacts::Generate::SQL::MYSQL)