sql_munger 0.0.7

data/lib/sql_munger/identifier_quoter.rb

@@ -0,0 +1,12 @@
+module SqlMunger
+
+# Quote a value in default SQL standard style. Probably
+# won't work for many backends, so the quote
+# method from, for example, DBI should be used.
+module IdentifierQuoter
+  def quote_ident( identifier )
+    %Q{"#{identifier}"}
+  end
+end
+
+end

data/lib/sql_munger/nodes.rb

@@ -0,0 +1,290 @@
+require 'sql_munger/sql_parser.rb'
+
+module TableNode
+  def fields
+    defns.select {|x| x.field? }
+  end
+  
+  def indices
+    @indices ||= []
+  end
+  
+  def constraints
+    defns.select {|x| x.constraint?}
+  end
+  
+  def defns
+    table_element_list.elements.map do |node|
+      node.table_element
+    end
+  end
+  
+  # Return the set of primary key field objects for this table.
+  # May be empty, or contain only one field.
+  def primary_key
+    single_key = fields.select{|f| f.clauses.any? {|c| c.clause_type == :primary_key } }
+    multi_key = constraints.select{ |x| x.type == :primary_key }
+    
+    if single_key.size > 1
+      raise "Can't have more than one primary key field specifier"
+    end
+    
+    if single_key.size > 0 && multi_key.size > 0
+      raise "Can't specify both single primary key and multi-key constraint"
+    end
+    
+    if single_key.size == 1
+      # return single key field name
+       [ single_key.first ]
+    elsif multi_key.size == 1
+      fields.select {|f| multi_key.first.fields.include?( f.name ) }
+    else
+      []
+    end
+  end
+  
+  # return the set of primary key field names for this table.
+  def primary_key_fields
+    primary_key.map{|f| f.name}
+  end
+  
+  def name
+    table_name.parts.last
+  end
+end
+
+module IndexNode
+  def unique?
+    !unique.text_value.empty?
+  end
+  
+  def qualified_fields
+    parenthesised_list.qualified_identifier_list.elements.map do |node|
+      node.qualified_identifier.parts
+    end
+  end
+  
+  def fields
+    qualified_fields.map {|x| x.last}
+  end
+  
+  def name
+    index_name.parts.last
+  end
+end
+
+module FieldNode
+  def field?; true; end
+  def constraint?; false; end
+  
+  def name
+    qualified_identifier.parts.last
+  end
+  
+  def sql_type
+    if type_specifier.terminal?
+      type_specifier.text_value
+    else
+      type_specifier.sql_type.text_value
+    end
+  end
+  
+  def primary_key?
+    clauses.any? {|x| x.clause_type == :primary_key }
+  end
+  
+  def rails_type
+    type_specifier.rails_type rescue sql_type
+  end
+  
+  def default?
+    !default_clause.nil?
+  end
+  
+  def default_clause
+    clauses.find {|x| x.clause_type == :default }
+  end
+  
+  def default
+    # do we have a default clause?
+    if default?
+      # fetch the default value
+      retval = default_clause.parenthesised.value
+      
+      # don't return a default of "null" because it's redundant
+      retval unless retval == "null"
+    end
+  end
+  
+  def null_clause
+    clauses.find {|x| x.clause_type == :not_null }
+  end
+  
+  def null
+    null_clause.nil?
+  end
+  
+  def rails_options
+    if @rails_options.nil?
+      @rails_options ||= {}
+      @rails_options[:limit] = length.to_i unless length.nil?
+      @rails_options[:precision] = precision.to_i unless precision.nil?
+      @rails_options[:scale] = scale.to_i unless scale.nil?
+      # only include a null specifier if it's false, ie we need a "not null" SQL clause
+      @rails_options[:null] = null unless ( null.nil? || null )
+      @rails_options[:default] = default unless default.nil?
+    end
+    @rails_options
+  end
+  
+  def formatted_rails_opts
+    if rails_options.empty?
+      ''
+    else
+      ", " + rails_options.inspect[1..-2].gsub( '=>', ' => ' )
+    end
+  end
+  
+  def length
+    type_specifier.length.text_value rescue nil
+  end
+  
+  def precision
+    type_specifier.args.precision.text_value rescue nil
+  end
+  
+  def scale
+    type_specifier.args.scale.text_value rescue nil
+  end
+  
+  # return text values of each clause
+  def clauses
+    if field_clauses.empty?
+      []
+    else
+      field_clauses.elements.map{|node| node.field_clause}
+    end
+  end
+end
+
+module ClauseNode
+  def clause_type
+    name.downcase.gsub( /\s+/, '_' ).to_sym
+  end
+end
+
+module SimpleFieldClauseNode
+  include ClauseNode
+  def name
+    text_value
+  end
+end
+
+module FieldClauseNode
+  include ClauseNode
+  def name
+    elements.first.text_value
+  end
+end
+
+module QualifiedIdentifierNode
+  # return an array of parts, each stripped of delimiters
+  def parts
+    elements.map do |node|
+      if node.identifier.respond_to?( :identifier )
+        node.identifier.identifier.text_value
+      else
+        node.identifier.text_value
+      end
+    end
+  end
+end
+
+# Rails migration types are
+# integer, float, datetime, date, timestamp
+# time, text, string, binary and boolean.
+module TypeNode
+end
+
+module TableConstraintNode
+  def field?; false; end
+  def constraint?; true; end
+  
+  def type
+    constraint_spec.constraint_clause.text_value.downcase.gsub( /\s+/, '_' ).to_sym
+  end
+  
+  def name
+    constraint_name.parts.last
+  end
+  
+  def fields
+    constraint_spec.parenthesised_list.qualified_identifier_list.elements.map do |node|
+      node.qualified_identifier.text_value
+    end
+  end
+  
+end
+
+module ParenthesisedNode
+
+  # this is actually def value, but it mustn't override
+  # the value methods for the literal nodes.
+  def method_missing( symbol, *args, &block )
+    if symbol == :value
+      parenthesised_value
+    else
+      super
+    end
+  end
+  
+  # this will end up being called for anything that's not handled by
+  # one of the XXXLiteralNode modules. Right now it basically applies
+  # to function calls only.
+  def parenthesised_value
+    node = self
+    while node.respond_to?( :parenthesised ) && !node.respond_to?( :function )
+      node = node.parenthesised
+    end
+    
+    unless node == self
+      node.value
+    else
+      text_value
+    end
+  end
+end
+
+module StringLiteral
+  def value
+    # strip delimiters and unescape
+    text_value[1..-2].gsub( "''", "'" )
+  end
+end
+
+module NumericLiteral
+  def value
+    if /[\.e]/ =~ text_value
+      text_value.to_f
+    else
+      text_value.to_i
+    end
+  end
+end
+
+module NullLiteral
+  def value
+    "null"
+  end
+end
+
+module BooleanLiteral
+  def value
+    eval text_value
+  end
+end
+
+class ParenthesisedList < Treetop::Runtime::SyntaxNode
+  def values
+  end
+end

data/lib/sql_munger/quoter.rb

@@ -0,0 +1,42 @@
+require 'sql_munger/identifier_quoter.rb'
+require 'sql_munger/value_quoter.rb'
+
+module SqlMunger
+
+module Quoter
+  class DefaultQuoter
+    include ValueQuoter
+    include IdentifierQuoter
+    def escape( st )
+      st.gsub( "'", "\\'" )
+    end
+  end
+  
+  attr_writer :quoter
+  
+  def quoter
+    @quoter ||= self.class.default_quoter
+  end
+  
+  def value_quoter
+    @value_quoter ||= quoter
+  end
+  
+  def identifier_quoter
+    @identifier_quoter ||= quoter
+  end
+
+  module ClassMethods
+    def default_quoter
+      @default_quoter ||= DefaultQuoter.new
+    end
+    
+    attr_writer :default_quoter
+  end
+  
+  def self.included( base )
+    base.extend( ClassMethods )
+  end
+end
+
+end

data/lib/sql_munger/sql.tt

@@ -0,0 +1,214 @@
+grammar Sql
+  rule data_defintion
+    ( s* statement s* terminator? s* )* {
+      def statements
+        elements.map { |node| node.elements[1] }
+      end
+      
+      def tables
+        statements.select {|x| x.is_a? TableNode }
+      end
+		
+		def indices
+        statements.select {|x| x.is_a? IndexNode }
+      end
+    }
+  end
+  
+  rule terminator
+    ';' / 'go'
+  end
+  
+  rule statement
+    create_table <TableNode>
+    / drop_table
+    / create_index <IndexNode>
+    / drop_index
+    / alter_table
+  end
+  
+  rule drop_table
+    'drop' s+ 'table' s+ table_name:qualified_identifier ( s+ drop_behaviour )?
+  end
+  
+  rule drop_behaviour
+    'cascade' / 'restrict'
+  end
+  
+  rule create_table
+    'create' s+ 'table' s+
+    # ( ( 'global' / 'local' ) sp 'temporary' )?
+    table_name:qualified_identifier s* '(' s* table_element_list s* ')'
+    #[ on commit { delete | preserve } rows ] 
+  end
+  
+  rule alter_table
+    'alter' s+ 'table' s+ table_name:qualified_identifier s+
+    'add' s+ table_constraint
+  end
+  
+  rule table_constraint
+    'constraint' s+ constraint_name:qualified_identifier s+
+    constraint_spec:( primary_key_constraint / foreign_key_constraint ) <TableConstraintNode>
+  end
+  
+  rule primary_key_constraint
+    constraint_clause:( 'primary' s+ 'key' )
+    s* parenthesised_list
+  end
+
+  rule foreign_key_constraint
+    constraint_clause:( 'foreign' s+ 'key' ) s*
+    referencing_columns:parenthesised_list s+
+    'references' s+ referenced_table:qualified_identifier s*
+    referenced_fields:parenthesised_list
+    on_delete:(  s+ 'on' s+ 'delete' s+ referential_action )?
+    on_update:(  s+ 'on' s+ 'update' s+ referential_action )?
+  end
+  
+  rule referential_action
+    'cascade' / ( 'set' s+ 'null' ) / ( 'set' s+ 'default' ) / ( 'no' s+ 'action' )
+  end
+
+  rule create_index
+    'create' s+ unique:( 'unique' s+ )? 'index' s+
+    index_name:qualified_identifier s+ 'on' s+ table_name:qualified_identifier s* parenthesised_list
+  end
+
+  rule drop_index
+    'drop' s+ 'index' identifier ( s+ drop_behaviour )?
+  end
+  
+  # actually whitespace or comment
+  rule s
+    [ \t\r\n] / comment
+  end
+  
+  rule comment
+    '--' (![\r\n] .)* [\r\n]
+  end
+  
+  rule qualified_identifier
+    ( '.'? identifier )+ <QualifiedIdentifierNode>
+  end
+  
+  rule qualified_identifier_list
+    ( s* ','? s* qualified_identifier )+
+  end
+
+  rule table_element_list
+    ( s* ','? s* table_element s* )+
+  end
+  
+  rule table_element
+    field_defn <FieldNode> / table_constraint
+  end
+  
+  rule field_defn
+    qualified_identifier s+ type_specifier field_clauses:(s+ field_clause)*
+  end
+  
+  rule unqualified_type_specifier
+    ( 'bit' / 'boolean' ) {
+      def rails_type; :boolean; end
+    }
+    
+    / ( 'smallint' / 'int' / 'tinyint' / 'bigint' / 'integer' ) {
+      def rails_type; :integer; end
+    }
+    
+    / ( 'datetime' / 'date' / 'time' / 'timestamp' ) {
+      def rails_type; text_value.to_sym; end
+    }
+    
+    / ( 'real' / 'double precision' ) {
+      def rails_type; :decimal; end
+    }
+    
+    / ( 'blob' / 'clob' / 'image' ) {
+      def rails_type; :binary; end
+    }
+
+    / ( 'text' ) {
+      def rails_type; :text; end
+    }
+  end
+  
+  rule type_specifier
+    ( unqualified_type_specifier / length_type_specifier / numeric_type_specifier ) <TypeNode>
+  end
+
+  rule length_type_specifier
+    sql_type:( 'n'? 'var'? 'char' ) s* '(' s* length:digit+ s* ')'
+    { def rails_type; :string; end }
+  end
+  
+  rule precision_scale
+    s* '(' s* precision:digit+ s* comma_scale:( ',' s* scale:digit+ )? s* ')' {
+      def scale
+        comma_scale.scale
+      end
+    }
+  end
+  
+  rule precision
+    s* '(' s* precision:digit+ s* ')'
+  end
+  
+  rule numeric_type_specifier
+    sql_type:('dec' 'imal'? / 'numeric' ) args:precision_scale?
+    { def rails_type; :decimal; end }
+    / sql_type:'float' args:precision? { def rails_type; :float; end }
+  end
+  
+  rule identifier
+    alpha ( alpha / digit / id_punct )* / delimiter identifier delimiter
+  end
+  
+  rule delimiter
+    ["\[\]`]
+  end
+  
+  rule word
+    alpha ( alpha / digit / id_punct )*
+  end
+
+  rule digit
+    [0-9]
+  end
+  
+  rule id_punct
+    [_]
+  end
+  
+  rule alpha
+    [a-zA-Z_] 
+  end
+
+  rule simple_field_clause
+    'identity' / 'primary' s+ 'key'/ 'unique'/ 'not' s+ 'null'
+  end
+
+  rule field_clause
+    simple_field_clause <SimpleFieldClauseNode>
+    / 'check' s* parenthesised <FieldClauseNode>
+    / 'default' s* parenthesised <FieldClauseNode>
+  end
+  
+  rule parenthesised
+    ( '(' s* parenthesised s* ')' / ( function:word s* parenthesised ) / literal / s* ) <ParenthesisedNode>
+  end
+  
+  rule literal
+    "'" ( "''" / (!"'" .) )* "'" <StringLiteral>
+    / [+-]? digit+ ( '.' digit+ )? ('e' digit+ )? <NumericLiteral>
+    / 'null' <NullLiteral>
+    / 'true' <BooleanLiteral>
+    / 'false' <BooleanLiteral>
+  end
+  
+  rule parenthesised_list
+    '(' s* qualified_identifier_list s* ')' <ParenthesisedList>
+  end
+  
+end