activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/lib/arjdbc/mysql/connection_methods.rb

@@ -0,0 +1,27 @@
+# Don't need to load native mysql adapter
+$LOADED_FEATURES << "active_record/connection_adapters/mysql_adapter.rb"
+$LOADED_FEATURES << "active_record/connection_adapters/mysql2_adapter.rb"
+
+class ActiveRecord::Base
+  class << self
+    def mysql_connection(config)
+      require "arjdbc/mysql"
+      config[:port] ||= 3306
+      options = (config[:options] ||= {})
+      options['zeroDateTimeBehavior'] ||= 'convertToNull'
+      options['jdbcCompliantTruncation'] ||= 'false'
+      options['useUnicode'] ||= 'true'
+      options['characterEncoding'] = config[:encoding] || 'utf8'
+      config[:url] ||= "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] ||= "com.mysql.jdbc.Driver"
+      config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter
+      connection = jdbc_connection(config)
+      ::ArJdbc::MySQL.kill_cancel_timer(connection.raw_connection)
+      connection
+    end
+    alias_method :jdbcmysql_connection, :mysql_connection
+    alias_method :mysql2_connection, :mysql_connection
+  end
+end
+
+

data/lib/arjdbc/oracle.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/oracle/connection_methods'
+require 'arjdbc/oracle/adapter'

data/lib/{jdbc_adapter/jdbc_oracle.rb → arjdbc/oracle/adapter.rb}

@@ -1,13 +1,8 @@
-module ::JdbcSpec
-  module ActiveRecordExtensions
-    def oracle_connection(config)
-      config[:port] ||= 1521
-      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
-      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
-      jdbc_connection(config)
-    end
-  end
+module ActiveRecord::ConnectionAdapters
+  OracleAdapter = Class.new(AbstractAdapter) unless const_defined?(:OracleAdapter)
+end
 
+module ::ArJdbc
   module Oracle
     def self.extended(mod)
       unless @lob_callback_added
@@ -26,24 +21,34 @@ module ::JdbcSpec
         ActiveRecord::Base.after_save :after_save_with_oracle_lob
         @lob_callback_added = true
       end
-      mod.class_eval do
-        alias_chained_method :insert, :query_dirty, :jdbc_oracle_insert
+      require 'arjdbc/jdbc/quoted_primary_key'
+      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
+      mod.class.class_eval do
+        alias_chained_method :insert, :query_dirty, :insert
+        alias_chained_method :columns, :query_cache, :columns
       end
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /oracle/i ? self : false
+    def self.column_selector
+      [/oracle/i, lambda {|cfg,col| col.extend(::ArJdbc::Oracle::Column)}]
     end
 
-    def self.column_selector
-      [/oracle/i, lambda {|cfg,col| col.extend(::JdbcSpec::Oracle::Column)}]
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::OracleJdbcConnection
     end
 
     module Column
+      def primary=(val)
+        super
+        if val && @sql_type =~ /^NUMBER$/i
+          @type = :integer
+        end
+      end
+
       def type_cast(value)
         return nil if value.nil?
         case type
-        when :datetime then JdbcSpec::Oracle::Column.string_to_time(value, self.class)
+        when :datetime then ArJdbc::Oracle::Column.string_to_time(value, self.class)
         else
           super
         end
@@ -51,7 +56,7 @@ module ::JdbcSpec
 
       def type_cast_code(var_name)
         case type
-        when :datetime  then "JdbcSpec::Oracle::Column.string_to_time(#{var_name}, self.class)"
+        when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name}, self.class)"
         else
           super
         end
@@ -63,8 +68,8 @@ module ::JdbcSpec
       end
 
       def self.guess_date_or_time(value)
-        (value.hour == 0 && value.min == 0 && value.sec == 0) ?
-        new_date(value.year, value.month, value.day) : value
+        (value && value.hour == 0 && value.min == 0 && value.sec == 0) ?
+        Date.new(value.year, value.month, value.day) : value
       end
 
       private
@@ -74,7 +79,7 @@ module ::JdbcSpec
         when /char/i                           then :string
         when /float|double/i                   then :float
         when /int/i                            then :integer
-        when /num|dec|real/i                   then @scale == 0 ? :integer : :decimal
+        when /num|dec|real/i                   then extract_scale(field_type) == 0 ? :integer : :decimal
         when /date|time/i                      then :datetime
         when /clob/i                           then :text
         when /blob/i                           then :binary
@@ -101,9 +106,18 @@ module ::JdbcSpec
     end
 
     def adapter_name
-      'oracle'
+      'Oracle'
     end
 
+    def arel2_visitors
+      { 'oracle' => Arel::Visitors::Oracle }
+    end
+
+    # TODO: use this instead of the QuotedPrimaryKey logic and execute_id_insert?
+    # def prefetch_primary_key?(table_name = nil)
+    #   columns(table_name).detect {|c| c.primary } if table_name
+    # end
+
     def table_alias_length
       30
     end
@@ -115,8 +129,9 @@ module ::JdbcSpec
     def create_table(name, options = {}) #:nodoc:
       super(name, options)
       seq_name = options[:sequence_name] || "#{name}_seq"
+      start_value = options[:sequence_start_value] || 10000
       raise ActiveRecord::StatementInvalid.new("name #{seq_name} too long") if seq_name.length > table_alias_length
-      execute "CREATE SEQUENCE #{seq_name} START WITH 10000" unless options[:id] == false
+      execute "CREATE SEQUENCE #{seq_name} START WITH #{start_value}" unless options[:id] == false
     end
 
     def rename_table(name, new_name) #:nodoc:
@@ -138,14 +153,27 @@ module ::JdbcSpec
       recreate_database(name)
     end
 
-    def jdbc_oracle_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      if id_value || pk.nil? # Pre-assigned id or table without a primary key
+    def next_sequence_value(sequence_name)
+      # avoid #select or #select_one so that the sequence values aren't cached
+      execute("select #{sequence_name}.nextval id from dual").first['id'].to_i
+    end
+
+    def sql_literal?(value)
+      defined?(::Arel::SqlLiteral) && ::Arel::SqlLiteral === value
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+      if (id_value && !sql_literal?(id_value)) || pk.nil?
+        # Pre-assigned id or table without a primary key
+        # Presence of #to_sql means an Arel literal bind variable
+        # that should use #execute_id_insert below
         execute sql, name
-      else # Assume the sql contains a bind-variable for the id
+      else
+        # Assume the sql contains a bind-variable for the id
         # Extract the table from the insert sql. Yuck.
         table = sql.split(" ", 4)[2].gsub('"', '')
         sequence_name ||= default_sequence_name(table)
-        id_value = select_one("select #{sequence_name}.nextval id from dual")['id'].to_i
+        id_value = next_sequence_value(sequence_name)
         log(sql, name) do
           @connection.execute_id_insert(sql,id_value)
         end
@@ -313,6 +341,12 @@ module ::JdbcSpec
     #
     # see: abstract/quoting.rb
 
+    # See ACTIVERECORD_JDBC-33 for details -- better to not quote
+    # table names, esp. if they have schemas.
+    def quote_table_name(name) #:nodoc:
+      name.to_s
+    end
+
     # Camelcase column names need to be quoted.
     # Nonquoted identifiers can contain only alphanumeric characters from your
     # database character set and the underscore (_), dollar sign ($), and pound sign (#).
@@ -328,6 +362,9 @@ module ::JdbcSpec
     end
 
     def quote(value, column = nil) #:nodoc:
+      # Arel 2 passes SqlLiterals through
+      return value if sql_literal?(value)
+
       if column && [:text, :binary].include?(column.type)
         if /(.*?)\([0-9]+\)/ =~ column.sql_type
           %Q{empty_#{ $1.downcase }()}
@@ -335,21 +372,19 @@ module ::JdbcSpec
           %Q{empty_#{ column.sql_type.downcase rescue 'blob' }()}
         end
       else
-        if column.respond_to?(:primary) && column.primary
+        if column.respond_to?(:primary) && column.primary && column.klass != String
           return value.to_i.to_s
         end
         quoted = super
-        if value.acts_like?(:date) || value.acts_like?(:time)
-          quoted = "#{quoted_date(value)}"
+        if value.acts_like?(:date)
+          quoted = %Q{DATE'#{quoted_date(value)}'}
+        elsif value.acts_like?(:time)
+          quoted = %Q{TIMESTAMP'#{quoted_date(value)}'}
         end
         quoted
       end
     end
 
-    def quoted_date(value)
-      %Q{TIMESTAMP'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-    end
-
     def quoted_true #:nodoc:
       '1'
     end

data/lib/arjdbc/oracle/connection_methods.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::Base
+  class << self
+    def oracle_connection(config)
+      config[:port] ||= 1521
+      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
+      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
+      jdbc_connection(config)
+    end
+  end
+end
+

data/lib/arjdbc/postgresql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/postgres'
+require 'arjdbc/postgresql/connection_methods'
+require 'arjdbc/postgresql/adapter'

data/lib/{jdbc_adapter/jdbc_postgre.rb → arjdbc/postgresql/adapter.rb}

@@ -1,29 +1,17 @@
+module ActiveRecord::ConnectionAdapters
+  PostgreSQLAdapter = Class.new(AbstractAdapter) unless const_defined?(:PostgreSQLAdapter)
+end
 
-module ::JdbcSpec
-  # Don't need to load native postgres adapter
-  $LOADED_FEATURES << "active_record/connection_adapters/postgresql_adapter.rb"
-
-  module ActiveRecordExtensions
-    add_method_to_remove_from_ar_base(:postgresql_connection)
-
-    def postgresql_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/postgresql_adapter"
-      config[:host] ||= "localhost"
-      config[:port] ||= 5432
-      config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:url] << config[:pg_params] if config[:pg_params]
-      config[:driver] ||= "org.postgresql.Driver"
-      jdbc_connection(config)
-    end
-  end
-
+module ::ArJdbc
   module PostgreSQL
-    def self.adapter_matcher(name, *)
-      name =~ /postgre/i ? self : false
+    def self.extended(mod)
+      mod.class.class_eval do
+        alias_chained_method :insert, :query_dirty, :insert
+      end
     end
 
     def self.column_selector
-      [/postgre/i, lambda {|cfg,col| col.extend(::JdbcSpec::PostgreSQL::Column)}]
+      [/postgre/i, lambda {|cfg,col| col.extend(::ArJdbc::PostgreSQL::Column)}]
     end
 
     def self.jdbc_connection_class
@@ -38,12 +26,21 @@ module ::JdbcSpec
         end
       end
 
+      def extract_limit(sql_type)
+        case sql_type
+        when /^bigint/i;    8
+        when /^smallint/i;  2
+        when /^(bool|text|date|time)/i; nil # ACTIVERECORD_JDBC-135,139
+        else super
+        end
+      end
+
       def simplified_type(field_type)
         return :integer if field_type =~ /^serial/i
         return :string if field_type =~ /\[\]$/i || field_type =~ /^interval/i
         return :string if field_type =~ /^(?:point|lseg|box|"?path"?|polygon|circle)/i
         return :datetime if field_type =~ /^timestamp/i
-        return :float if field_type =~ /^real|^money/i
+        return :float if field_type =~ /^(?:real|double precision)$/i
         return :binary if field_type =~ /^bytea/i
         return :boolean if field_type =~ /^bool/i
         super
@@ -83,10 +80,25 @@ module ::JdbcSpec
       tp[:primary_key] = "serial primary key"
       tp[:string][:limit] = 255
       tp[:integer][:limit] = nil
-      tp[:boolean][:limit] = nil
+      tp[:boolean] = { :name => "boolean" }
+      tp[:float] = { :name => "float" }
+      tp[:text] = { :name => "text" }
+      tp[:datetime] = { :name => "timestamp" }
+      tp[:timestamp] = { :name => "timestamp" }
+      tp[:time] = { :name => "time" }
+      tp[:date] = { :name => "date" }
+      tp[:decimal] = { :name => "decimal" }
       tp
     end
 
+    def adapter_name #:nodoc:
+      'PostgreSQL'
+    end
+
+    def arel2_visitors
+      {'jdbcpostgresql' => ::Arel::Visitors::PostgreSQL}
+    end
+
     def postgresql_version
       @postgresql_version ||=
         begin
@@ -132,10 +144,26 @@ module ::JdbcSpec
       true
     end
 
+    def supports_count_distinct? #:nodoc:
+      false
+    end
+
+    def create_savepoint
+      execute("SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def rollback_to_savepoint
+      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def release_savepoint
+      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+    end
+
     # Returns the configured supported identifier length supported by PostgreSQL,
     # or report the default of 63 on PostgreSQL 7.x.
     def table_alias_length
-      @table_alias_length ||= (postgresql_version >= 80000 ? select('SHOW max_identifier_length').to_a[0][0].to_i : 63)
+      @table_alias_length ||= (postgresql_version >= 80000 ? select_one('SHOW max_identifier_length')['max_identifier_length'].to_i : 63)
     end
 
     def default_sequence_name(table_name, pk = nil)
@@ -163,12 +191,6 @@ module ::JdbcSpec
       end
     end
 
-    def quote_regclass(table_name)
-      table_name.to_s.split('.').map do |part| 
-        part =~ /".*"/i ? part : quote_table_name(part)
-      end.join('.')  
-    end
-
     # Find a table's primary key and sequence.
     def pk_and_sequence_for(table) #:nodoc:
       # First try looking for a sequence with a dependency on the
@@ -187,14 +209,14 @@ module ::JdbcSpec
             AND attr.attrelid     = cons.conrelid
             AND attr.attnum       = cons.conkey[1]
             AND cons.contype      = 'p'
-            AND dep.refobjid      = '#{table}'::regclass
+            AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
         end_sql
 
       if result.nil? or result.empty?
         # If that fails, try parsing the primary key's default value.
         # Support the 7.x and 8.0 nextval('foo'::text) as well as
         # the 8.1+ nextval('foo'::regclass).
-        result = query(<<-end_sql, 'PK and custom sequence')[0]
+        result = select(<<-end_sql, 'PK and custom sequence')[0]
             SELECT attr.attname,
               CASE
                 WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
@@ -206,7 +228,7 @@ module ::JdbcSpec
             JOIN pg_attribute   attr ON (t.oid = attrelid)
             JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
             JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
-            WHERE t.oid = '#{table}'::regclass
+            WHERE t.oid = '#{quote_table_name(table)}'::regclass
               AND cons.contype = 'p'
               AND def.adsrc ~* 'nextval'
           end_sql
@@ -222,10 +244,7 @@ module ::JdbcSpec
       table = sql.split(" ", 4)[2].gsub('"', '')
 
       # Try an insert with 'returning id' if available (PG >= 8.2)
-      if supports_insert_with_returning? && id_value.nil? && false # FIXME:
-        # Disabled, as it causes:
-        # ActiveRecord::ActiveRecordError: A result was returned when none was expected
-        # This was previously disabled because postgresql_version returned 0
+      if supports_insert_with_returning? && id_value.nil?
         pk, sequence_name = *pk_and_sequence_for(table) unless pk
         if pk
           id_value = select_value("#{sql} RETURNING #{quote_column_name(pk)}")
@@ -255,7 +274,7 @@ module ::JdbcSpec
     end
 
     def columns(table_name, name=nil)
-      schema_name = "public"
+      schema_name = @config[:schema_search_path]
       if table_name =~ /\./
         parts = table_name.split(/\./)
         table_name = parts.pop
@@ -312,7 +331,24 @@ module ::JdbcSpec
     end
 
     def drop_database(name)
-      execute "DROP DATABASE \"#{name}\""
+      execute "DROP DATABASE IF EXISTS \"#{name}\""
+    end
+
+    def create_schema(schema_name, pg_username)
+      execute("CREATE SCHEMA \"#{schema_name}\" AUTHORIZATION \"#{pg_username}\"")
+    end
+
+    def drop_schema(schema_name)
+      execute("DROP SCHEMA \"#{schema_name}\"")
+    end
+
+    def all_schemas
+      select('select nspname from pg_namespace').map {|r| r["nspname"] }
+    end
+
+    def primary_key(table)
+      pk_and_sequence = pk_and_sequence_for(table)
+      pk_and_sequence && pk_and_sequence.first
     end
 
     def structure_dump
@@ -343,15 +379,6 @@ module ::JdbcSpec
       end
     end
 
-    def _execute(sql, name = nil)
-        case sql.strip
-        when /\A\(?\s*(select|show)/i then
-          @connection.execute_query(sql)
-        else
-          @connection.execute_update(sql)
-        end
-    end
-
     # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
     #
     # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
@@ -387,13 +414,23 @@ module ::JdbcSpec
       sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
     end
 
-    def quote(value, column = nil)
-      return value.quoted_id if value.respond_to?(:quoted_id)
+    def quote(value, column = nil) #:nodoc:
+      return super unless column
 
-      if value.kind_of?(String) && column && column.type == :binary
+      if value.kind_of?(String) && column.type == :binary
         "'#{escape_bytea(value)}'"
-      elsif column && column.type == :primary_key
-        return value.to_s
+      elsif value.kind_of?(String) && column.sql_type == 'xml'
+        "xml '#{quote_string(value)}'"
+      elsif value.kind_of?(Numeric) && column.sql_type == 'money'
+        # Not truly string input, so doesn't require (or allow) escape string syntax.
+        "'#{value}'"
+      elsif value.kind_of?(String) && column.sql_type =~ /^bit/
+        case value
+        when /^[01]*$/
+          "B'#{value}'" # Bit-string notation
+        when /^[0-9A-F]*$/i
+          "X'#{value}'" # Hexadecimal notation
+        end
       else
         super
       end
@@ -407,6 +444,17 @@ module ::JdbcSpec
       end
     end
 
+    def quote_table_name(name)
+      schema, name_part = extract_pg_identifier_from_name(name.to_s)
+
+      unless name_part
+        quote_column_name(schema)
+      else
+        table_name, name_part = extract_pg_identifier_from_name(name_part)
+        "#{quote_column_name(schema)}.#{quote_column_name(table_name)}"
+      end
+    end
+
     def quote_column_name(name)
       %("#{name}")
     end
@@ -430,32 +478,48 @@ module ::JdbcSpec
       execute "ALTER TABLE #{name} RENAME TO #{new_name}"
     end
 
+    # Adds a new column to the named table.
+    # See TableDefinition#column for details of the options you can use.
     def add_column(table_name, column_name, type, options = {})
-      execute("ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit])}")
-      change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
-      if options[:null] == false
-        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)} = '#{options[:default]}'") if options[:default]
-        execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} SET NOT NULL")
-      end
+      default = options[:default]
+      notnull = options[:null] == false
+
+      # Add the column.
+      execute("ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
+
+      change_column_default(table_name, column_name, default) if options_include_default?(options)
+      change_column_null(table_name, column_name, false, default) if notnull
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # Changes the column of a table.
+    def change_column(table_name, column_name, type, options = {})
+      quoted_table_name = quote_table_name(table_name)
+
       begin
-        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit])}"
-      rescue ActiveRecord::StatementInvalid
-        # This is PG7, so we use a more arcane way of doing it.
-        begin_db_transaction
-        add_column(table_name, "#{column_name}_ar_tmp", type, options)
-        execute "UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit])})"
-        remove_column(table_name, column_name)
-        rename_column(table_name, "#{column_name}_ar_tmp", column_name)
-        commit_db_transaction
+        execute "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      rescue ActiveRecord::StatementInvalid => e
+        raise e if postgresql_version > 80000
+        # This is PostgreSQL 7.x, so we have to use a more arcane way of doing it.
+        begin
+          begin_db_transaction
+          tmp_column_name = "#{column_name}_ar_tmp"
+          add_column(table_name, tmp_column_name, type, options)
+          execute "UPDATE #{quoted_table_name} SET #{quote_column_name(tmp_column_name)} = CAST(#{quote_column_name(column_name)} AS #{type_to_sql(type, options[:limit], options[:precision], options[:scale])})"
+          remove_column(table_name, column_name)
+          rename_column(table_name, tmp_column_name, column_name)
+          commit_db_transaction
+        rescue
+          rollback_db_transaction
+        end
       end
-      change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
+
+      change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+      change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
     end
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT '#{default}'"
+    # Changes the default value of a table column.
+    def change_column_default(table_name, column_name, default)
+      execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
     end
 
     def change_column_null(table_name, column_name, null, default = nil)
@@ -488,6 +552,17 @@ module ::JdbcSpec
     def tables
       @connection.tables(database_name, nil, nil, ["TABLE"])
     end
+
+    private
+    def extract_pg_identifier_from_name(name)
+      match_data = name[0,1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
+
+      if match_data
+        rest = name[match_data[0].length..-1]
+        rest = rest[1..-1] if rest[0,1] == "."
+        [match_data[1], (rest.length > 0 ? rest : nil)]
+      end
+    end
   end
 end