create_table 0.1.0

data/lib/create_table/column.rl

@@ -0,0 +1,338 @@
+# MAKE SURE YOU'RE EDITING THE .RL FILE !!!
+
+=begin
+%%{
+  machine parser;
+
+  include "common.rl";
+
+  action StartName {
+    start_name = p
+  }
+  action EndName {
+    self.name = read(data, start_name, p)
+  }
+
+  action StartDataType {
+    start_data_type = p
+  }
+
+  action MarkNotNull {
+    mark_not_null = p - 4
+  }
+  action Null {
+    start_default ||= nil
+    unless start_default # FIXME could this be excluded by the state machine instead?
+      mark_not_null ||= nil
+      if mark_not_null
+        self.null = false
+        end_data_type ||= mark_not_null
+      else
+        self.null = true
+        end_data_type ||= p - 4
+      end
+    end
+  }
+
+  action MarkDefault {
+    mark_default = p - 1
+  }
+  action StartDefault {
+    start_default = p
+    end_data_type ||= mark_default
+  }
+  action EndQuotedDefault {
+    end_default = p
+    self.default = read_quoted(data, start_default, end_default)
+    ended_quoted_default = true
+  }
+
+  action MarkPrimaryKey {
+    mark_primary_key = p - 1
+  }
+  action PrimaryKey {
+    primary_key!
+    end_data_type ||= mark_primary_key
+    end_default ||= mark_primary_key
+  }
+
+  action MarkUnique {
+    mark_unique = p - 5
+  }
+  action Unique {
+    unique!
+    end_data_type ||= mark_unique
+    end_default ||= mark_unique
+  }
+
+  action MarkAutoincrement {
+    mark_autoincrement = p - 1
+  }
+  action Autoincrement {
+    autoincrement!
+    end_data_type ||= mark_autoincrement
+    end_default ||= mark_autoincrement
+  }
+
+  action MarkCollate {
+    mark_collate = p - 1
+  }
+  action StartCollate {
+    start_collate = p
+  }
+  action EndCollate {
+    self.collate = read_quoted(data, start_collate, p)
+    end_data_type ||= mark_collate
+    end_default ||= mark_collate
+  }
+
+  action MarkCharset {
+    mark_charset = p - 5
+  }
+  action StartCharset {
+    start_charset = p
+  }
+  action EndCharset {
+    self.charset = read_quoted(data, start_charset, p)
+    end_data_type ||= mark_charset
+    end_default ||= mark_charset
+  }
+
+  action BitterEnd {
+    # EndUnquotedDefault
+    start_default ||= nil
+    ended_quoted_default ||= nil
+    if start_default and not ended_quoted_default
+      end_default ||= p
+      self.default = read_quoted(data, start_default, end_default)
+    end
+    # EndDataType
+    end_data_type ||= p
+    self.data_type = read(data, start_data_type, end_data_type)
+  }
+
+  name                    = quote_ident ident >StartName %EndName quote_ident;
+  
+  primary_key             = ('primary'i space+ 'key'i) >MarkPrimaryKey @PrimaryKey;
+  
+  autoincrement           = ('auto'i '_'? 'increment'i) >MarkAutoincrement @Autoincrement;
+  
+  unique                  = 'uniq'i %MarkUnique 'ue'i @Unique;
+  
+  quoted_default_value    = quote_value (not_quote_or_escape | escaped_something | quoted_quote)+ >StartDefault %EndQuotedDefault quote_value;
+  unquoted_default_value  = (alnum any*) >StartDefault; # space*;
+  default                 = ('default'i space+) >MarkDefault (quoted_default_value | unquoted_default_value);
+  
+  _null                   = ('not'i %MarkNotNull)? space+ 'null'i @Null;
+  
+  quoted_charset_value    = quote_value (not_quote_or_escape | escaped_something | quoted_quote)+ >StartCharset %EndCharset quote_value;
+  unquoted_charset_value  = (any - space)+ >StartCharset %EndCharset space*;
+  charset                 = 'char'i %MarkCharset ('set'i | ('acter'i space+ 'set'i)) space+ (quoted_charset_value | unquoted_charset_value);
+  
+  quoted_collate_value    = quote_value (not_quote_or_escape | escaped_something | quoted_quote)+ >StartCollate %EndCollate quote_value;
+  unquoted_collate_value  = (any - space)+ >StartCollate %EndCollate space*;
+  collate                 = ('collate'i space+) >MarkCollate (quoted_collate_value | unquoted_collate_value);
+  
+  data_type               = any+;
+
+  main := space* name space+ data_type >StartDataType _null? default? primary_key? unique? autoincrement? charset? collate? %BitterEnd;
+}%%
+=end
+
+class CreateTable
+  class Column
+    class << self
+      def munge_data_type(original, ansi)
+        if original =~ /\((.*)\)/
+          [ ansi, '(', $1, ')' ].join
+        else
+          ansi
+        end
+      end
+    end
+
+    BLANK_STRING = ''
+
+    include Parser
+
+    attr_reader :parent
+    attr_reader :name
+    attr_reader :data_type
+    attr_writer :default
+    attr_writer :null
+    attr_accessor :charset
+    attr_accessor :collate
+
+    def initialize(parent)
+      @parent = parent
+      parent.columns << self
+    end
+
+    def name=(name)
+      @name = name
+    end
+
+    def data_type=(str)
+      str = str.upcase
+      case str
+      when /SERIAL/
+        autoincrement!
+        @data_type = 'INTEGER'
+      when 'INT IDENTITY(1,1)'
+        # TODO is this correct?
+        autoincrement!
+        primary_key!
+        @data_type = 'INTEGER'
+      when 'TINYINT(1)'
+        @data_type = 'BOOLEAN'
+      when 'INT(11)'
+        @data_type = 'INTEGER'
+      when /\bINT\b/
+        @data_type = Column.munge_data_type str, 'INTEGER'
+      when /\bVARCHAR\b/
+        @data_type = Column.munge_data_type str, 'CHARACTER VARYING'
+      else
+        @data_type = str
+      end
+    end
+
+    def default
+      if defined?(@default)
+        @default
+      elsif primary_key and data_type =~ /char/i
+        BLANK_STRING
+      end
+    end
+
+    def null
+      if defined?(@null)
+        @null
+      elsif primary_key
+        false
+      else
+        true
+      end
+    end
+
+    alias :allow_null :null
+
+    def primary_key
+      parent.primary_key == self
+    end
+
+    def primary_key!
+      parent.primary_key = name
+    end
+
+    def unique
+      if primary_key
+        true
+      elsif index = parent.indexes[name]
+        index.unique
+      else
+        false
+      end
+    end
+
+    def named_unique
+      unique and parent.indexes[name].name
+    end
+
+    def unique!
+      parent.add_unique name
+    end
+
+    def index!
+      parent.add_index name
+    end
+
+    def indexed
+      primary_key or !!parent.indexes[name]
+    end
+
+    def autoincrement!
+      @autoincrement = true
+    end
+
+    def autoincrement
+      if defined?(@autoincrement)
+        @autoincrement
+      elsif default and default =~ /nextval/i
+        true
+      else
+        false
+      end
+    end
+
+    # @private
+    def column_names
+      [name]
+    end
+
+    def parse(str)
+      data = Parser.remove_comments(str).strip.unpack('c*')
+      %% write data;
+      # % (this fixes syntax highlighting)
+      parens = 0
+      p = item = 0
+      pe = eof = data.length
+      %% write init;
+      # % (this fixes syntax highlighting)
+      %% write exec;
+      # % (this fixes syntax highlighting)
+      self
+    end
+
+    # generating
+
+    def to_sql(format, options)
+      send "to_#{format}", options
+    end
+
+    def to_mysql(options)
+      parts = []
+      parts << CreateTable.quote_ident(name, options)
+      parts << data_type
+      if primary_key
+        parts << 'PRIMARY KEY'
+      elsif unique and not named_unique
+        parts << 'UNIQUE'
+      end
+      if autoincrement
+        parts << 'AUTO_INCREMENT'
+      end
+      parts.join ' '
+    end
+
+    def to_postgresql(options)
+      parts = []
+      parts << CreateTable.quote_ident(name, options)
+      if autoincrement and data_type =~ /integer/i
+        parts << 'SERIAL'
+      else
+        parts << data_type
+      end
+      if primary_key
+        parts << 'PRIMARY KEY'
+      elsif unique and not named_unique
+        parts << 'UNIQUE'
+      end
+      parts.join ' '
+    end
+
+    def to_sqlite3(options)
+      parts = []
+      parts << CreateTable.quote_ident(name, options)
+      parts << data_type
+      if primary_key
+        parts << 'PRIMARY KEY'
+      elsif unique and not named_unique
+        parts << 'UNIQUE'
+      end
+      if autoincrement
+        parts << 'AUTOINCREMENT'
+      end
+      parts.join ' '
+    end
+  end
+end

data/lib/create_table/column_name_based_collection.rb

@@ -0,0 +1,26 @@
+require 'delegate'
+class CreateTable
+  class ColumnNameBasedCollection < Delegator
+    class << self
+      def create
+        new([])
+      end
+    end
+
+    def __getobj__
+      @items
+    end
+
+    def __setobj__(items)
+      @items = items
+    end
+
+    def [](column_names)
+      return if column_names.nil?
+      k = [column_names].flatten
+      retval = @items.select { |i| i.column_names == k }
+      raise "oops #{k.inspect}: #{retval.map(&:column_names).inspect}" if retval.length > 1
+      retval.first
+    end
+  end
+end

data/lib/create_table/common.rb

@@ -0,0 +1,5 @@
+
+# line 1 "/Users/seamusabshere/code/create_table/lib/create_table/common.rl.tmp"
+
+# line 10 "/Users/seamusabshere/code/create_table/lib/create_table/common.rl.tmp"
+

data/lib/create_table/common.rl

@@ -0,0 +1,13 @@
+%%{
+  machine parser;
+  ident               = [_a-zA-Z][_a-zA-Z0-9]*;
+  quote_ident         = ["`]?;
+  quote_value         = ['"];
+  lparens             = space* '(' space*;
+  rparens             = space* ')' space*;
+  parens_counter      = ( any | '(' @{parens+=1} | ')' @{parens-=1} )*;
+  with_parens         = any+ & parens_counter;
+  not_quote_or_escape = [^'"\\];
+  escaped_something   = /\\./;
+  quoted_quote        = "''";
+}%%

data/lib/create_table/index.rb

@@ -0,0 +1,315 @@
+
+# MAKE SURE YOU'RE EDITING THE .RL FILE !!!
+
+=begin
+
+
+=end
+
+class CreateTable
+  class Index
+    include Parser
+
+    attr_reader :parent
+    attr_reader :column_names
+    attr_accessor :name
+    
+    def initialize(parent)
+      @parent = parent
+      @column_names = []
+      parent.indexes << self
+    end
+
+    def unique
+      false
+    end
+
+    def parse(str)
+      data = Parser.remove_comments(str).unpack('c*')
+      
+class << self
+	attr_accessor :_parser_actions
+	private :_parser_actions, :_parser_actions=
+end
+self._parser_actions = [
+	0, 1, 0, 1, 1, 1, 2, 1, 
+	3
+]
+
+class << self
+	attr_accessor :_parser_key_offsets
+	private :_parser_key_offsets, :_parser_key_offsets=
+end
+self._parser_key_offsets = [
+	0, 0, 10, 15, 27, 31, 40, 45, 
+	55, 57, 67
+]
+
+class << self
+	attr_accessor :_parser_trans_keys
+	private :_parser_trans_keys, :_parser_trans_keys=
+end
+self._parser_trans_keys = [
+	32, 34, 40, 96, 9, 13, 65, 90, 
+	95, 122, 95, 65, 90, 97, 122, 32, 
+	34, 40, 96, 9, 13, 48, 57, 65, 
+	90, 95, 122, 32, 40, 9, 13, 32, 
+	34, 96, 9, 13, 65, 90, 95, 122, 
+	95, 65, 90, 97, 122, 34, 41, 44, 
+	96, 48, 57, 65, 90, 95, 122, 41, 
+	44, 32, 34, 41, 96, 9, 13, 65, 
+	90, 95, 122, 32, 9, 13, 0
+]
+
+class << self
+	attr_accessor :_parser_single_lengths
+	private :_parser_single_lengths, :_parser_single_lengths=
+end
+self._parser_single_lengths = [
+	0, 4, 1, 4, 2, 3, 1, 4, 
+	2, 4, 1
+]
+
+class << self
+	attr_accessor :_parser_range_lengths
+	private :_parser_range_lengths, :_parser_range_lengths=
+end
+self._parser_range_lengths = [
+	0, 3, 2, 4, 1, 3, 2, 3, 
+	0, 3, 1
+]
+
+class << self
+	attr_accessor :_parser_index_offsets
+	private :_parser_index_offsets, :_parser_index_offsets=
+end
+self._parser_index_offsets = [
+	0, 0, 8, 12, 21, 25, 32, 36, 
+	44, 47, 55
+]
+
+class << self
+	attr_accessor :_parser_indicies
+	private :_parser_indicies, :_parser_indicies=
+end
+self._parser_indicies = [
+	0, 2, 3, 2, 0, 4, 4, 1, 
+	4, 4, 4, 1, 5, 5, 6, 5, 
+	5, 7, 7, 7, 1, 8, 3, 8, 
+	1, 3, 9, 9, 3, 10, 10, 1, 
+	10, 10, 10, 1, 11, 12, 12, 11, 
+	13, 13, 13, 1, 14, 14, 1, 14, 
+	9, 15, 9, 14, 10, 10, 1, 15, 
+	15, 1, 0
+]
+
+class << self
+	attr_accessor :_parser_trans_targs
+	private :_parser_trans_targs, :_parser_trans_targs=
+end
+self._parser_trans_targs = [
+	1, 0, 2, 5, 3, 4, 5, 3, 
+	4, 6, 7, 8, 9, 7, 9, 10
+]
+
+class << self
+	attr_accessor :_parser_trans_actions
+	private :_parser_trans_actions, :_parser_trans_actions=
+end
+self._parser_trans_actions = [
+	0, 0, 0, 0, 1, 3, 3, 0, 
+	0, 0, 5, 7, 7, 0, 0, 0
+]
+
+class << self
+	attr_accessor :parser_start
+end
+self.parser_start = 1;
+class << self
+	attr_accessor :parser_first_final
+end
+self.parser_first_final = 10;
+class << self
+	attr_accessor :parser_error
+end
+self.parser_error = 0;
+
+class << self
+	attr_accessor :parser_en_main
+end
+self.parser_en_main = 1;
+
+
+      # % (this fixes syntax highlighting)
+      parens = 0
+      p = item = 0
+      pe = eof = data.length
+      
+begin
+	p ||= 0
+	pe ||= data.length
+	cs = parser_start
+end
+
+      # % (this fixes syntax highlighting)
+      
+begin
+	_klen, _trans, _keys, _acts, _nacts = nil
+	_goto_level = 0
+	_resume = 10
+	_eof_trans = 15
+	_again = 20
+	_test_eof = 30
+	_out = 40
+	while true
+	_trigger_goto = false
+	if _goto_level <= 0
+	if p == pe
+		_goto_level = _test_eof
+		next
+	end
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	end
+	if _goto_level <= _resume
+	_keys = _parser_key_offsets[cs]
+	_trans = _parser_index_offsets[cs]
+	_klen = _parser_single_lengths[cs]
+	_break_match = false
+	
+	begin
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + _klen - 1
+
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + ( (_upper - _lower) >> 1 )
+
+	        if data[p].ord < _parser_trans_keys[_mid]
+	           _upper = _mid - 1
+	        elsif data[p].ord > _parser_trans_keys[_mid]
+	           _lower = _mid + 1
+	        else
+	           _trans += (_mid - _keys)
+	           _break_match = true
+	           break
+	        end
+	     end # loop
+	     break if _break_match
+	     _keys += _klen
+	     _trans += _klen
+	  end
+	  _klen = _parser_range_lengths[cs]
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + (_klen << 1) - 2
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + (((_upper-_lower) >> 1) & ~1)
+	        if data[p].ord < _parser_trans_keys[_mid]
+	          _upper = _mid - 2
+	        elsif data[p].ord > _parser_trans_keys[_mid+1]
+	          _lower = _mid + 2
+	        else
+	          _trans += ((_mid - _keys) >> 1)
+	          _break_match = true
+	          break
+	        end
+	     end # loop
+	     break if _break_match
+	     _trans += _klen
+	  end
+	end while false
+	_trans = _parser_indicies[_trans]
+	cs = _parser_trans_targs[_trans]
+	if _parser_trans_actions[_trans] != 0
+		_acts = _parser_trans_actions[_trans]
+		_nacts = _parser_actions[_acts]
+		_acts += 1
+		while _nacts > 0
+			_nacts -= 1
+			_acts += 1
+			case _parser_actions[_acts - 1]
+when 0 then
+		begin
+ start_name = p                                    		end
+when 1 then
+		begin
+ self.name = read(data, start_name, p)             		end
+when 2 then
+		begin
+ start_column_name = p                             		end
+when 3 then
+		begin
+ column_names << read(data, start_column_name, p)  		end
+			end # action switch
+		end
+	end
+	if _trigger_goto
+		next
+	end
+	end
+	if _goto_level <= _again
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	p += 1
+	if p != pe
+		_goto_level = _resume
+		next
+	end
+	end
+	if _goto_level <= _test_eof
+	end
+	if _goto_level <= _out
+		break
+	end
+	end
+	end
+
+      # % (this fixes syntax highlighting)
+      self
+    end
+
+    def column_names=(column_names)
+      @column_names = [column_names].compact.flatten
+    end
+
+    def to_sql(format, options)
+      return if primary_key
+      return if unique and name.nil?
+      parts = []
+      parts << 'CREATE'
+      parts << 'UNIQUE' if (unique and name)
+      parts << 'INDEX'
+      parts += [ quoted_name(options), 'ON', parent.quoted_table_name(options), '(', quoted_column_names(options), ')' ]
+      parts.join ' '
+    end
+
+    def primary_key
+      if pk = parent.primary_key
+        pk.column_names == column_names
+      end
+    end
+
+    def quoted_name(options)
+      if name
+        CreateTable.quote_ident name, options
+      elsif unique
+        "uidx_#{parent.table_name}_on_#{name}"
+      else
+        "idx_#{parent.table_name}_on_#{name}"
+      end
+    end
+
+    def quoted_column_names(options)
+      column_names.map do |column_name|
+        CreateTable.quote_ident column_name, options
+      end.join(', ')
+    end
+  end
+end