antlr.rake

# typed: false
# frozen_string_literal: true

require "bundler"
require "antlr4-native"
require "etc"
require "rubygems/package"
require "zlib"
require "open-uri"

namespace :antlr do
  namespace :runtime do
    task clone: :environment do
      dest = "ext/lib/antlr4-cpp-runtime"

      tag = Antlr4Native::Generator::ANTLR_VERSION
      base = "antlr4-#{tag}/runtime/Cpp/runtime/src/"

      url = "https://github.com/antlr/antlr4/archive/refs/tags/#{tag}.tar.gz"

      puts "Extracting #{base} from #{url} to #{dest}"
      FileUtils.rm_rf(dest)

      URI.parse(url).open do |file|
        # Taken from https://stackoverflow.com/a/11505644
        tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.new(file))
        found = false
        tar_extract.each do |entry|
          unless found
            # Seek
            next unless entry.full_name == base

            found = true
          end

          break unless entry.full_name.start_with?(base)
          next unless entry.file?

          dest_path = File.join(dest, entry.full_name[base.length..-1])
          puts dest_path

          FileUtils.mkdir_p(File.dirname(dest_path))
          File.open(dest_path, "wb") do |f|
            IO.copy_stream(entry, f)
          end
        end
        tar_extract.close

        raise "Could not find the #{base} directory" unless found
      end
    end
  end

  namespace :python do
    desc "Generate the MySQL parser"
    task generate: :environment do
      generator = Antlr4Native::Generator.new(
        grammar_files:      ["Python3Lexer.g4", "Python3Parser.g4"],
        output_dir:         "ext",
        parser_root_method: "file_input",
      )

      generator.generate
    end

    desc "Compile the MySQL parser"
    task compile: :environment do
      Dir.chdir("ext/python3_parser") do
        load "extconf.rb"
        exec "make -j #{Etc.nprocessors}"
      end
    end
  end

  namespace :mysql do
    desc "Generate the MySQL parser"
    task generate: :environment do
      generator = Antlr4Native::Generator.new(
        grammar_files:      ["MySqlLexer.g4", "MySqlParser.g4"],
        output_dir:         "ext",
        parser_root_method: "root",
      )

      generator.generate
    end

    desc "Compile the MySQL parser"
    task compile: :environment do
      Dir.chdir("ext/my_sql_parser") do
        load "extconf.rb"
        exec "make -j #{Etc.nprocessors}"
      end
    end
  end
end

extconf.rb

# frozen_string_literal: true

# Source: https://github.com/camertron/antlr4-native-rb/blob/174e01670cff38ac7a63172eefab1b0cdf6f6f00/spec/lua-parser-rb/ext/lua_parser/extconf.rb

# rubocop:disable

require "mkmf-rice"

extension_name = File.basename(__dir__)
dir_config(extension_name)

have_library("stdc++")

$CFLAGS << " -std=c++14"

if enable_config("static")
  $defs.push("-DANTLR4CPP_STATIC") if $defs.exclude?("-DANTLR4CPP_STATIC")
end

include_paths = [
  ".",
  "antlrgen",
  "../lib/antlr4-cpp-runtime",
  "../lib/antlr4-cpp-runtime/atn",
  "../lib/antlr4-cpp-runtime/dfa",
  "../lib/antlr4-cpp-runtime/misc",
  "../lib/antlr4-cpp-runtime/support",
  "../lib/antlr4-cpp-runtime/tree",
  "../lib/antlr4-cpp-runtime/tree/pattern",
  "../lib/antlr4-cpp-runtime/tree/xpath",
]

$srcs = []

include_paths.each do |include_path|
  $INCFLAGS << " -I#{include_path}"
  $VPATH << include_path

  Dir.glob("#{include_path}/*.cpp").each do |path|
    $srcs << path
  end
end

create_makefile(extension_name)

make.log

Running via Spring preloader in process 1831
checking for rice/rice.hpp in /Users/seb/.gem/ruby/3.2.2/gems/rice-4.3.1/include... yes
checking for -lc++... yes
checking for -lstdc++... yes
creating Makefile
compiling my_sql_parser.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PrecedencePredicateTransition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredicateEvalInfo.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredicateTransition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredictionContext.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredictionContextCache.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredictionContextMergeCache.cpp
compiling ../lib/antlr4-cpp-runtime/atn/PredictionMode.cpp
compiling ../lib/antlr4-cpp-runtime/atn/ProfilingATNSimulator.cpp
compiling ../lib/antlr4-cpp-runtime/atn/RangeTransition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/RuleTransition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/SemanticContext.cpp
compiling ../lib/antlr4-cpp-runtime/atn/SetTransition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/SingletonPredictionContext.cpp
compiling ../lib/antlr4-cpp-runtime/atn/StarLoopbackState.cpp
compiling ../lib/antlr4-cpp-runtime/atn/Transition.cpp
compiling ../lib/antlr4-cpp-runtime/atn/TransitionType.cpp
compiling ../lib/antlr4-cpp-runtime/atn/WildcardTransition.cpp
compiling ../lib/antlr4-cpp-runtime/dfa/DFA.cpp
compiling ../lib/antlr4-cpp-runtime/dfa/DFASerializer.cpp
compiling ../lib/antlr4-cpp-runtime/dfa/DFAState.cpp
compiling ../lib/antlr4-cpp-runtime/dfa/LexerDFASerializer.cpp
compiling ../lib/antlr4-cpp-runtime/misc/InterpreterDataReader.cpp
compiling ../lib/antlr4-cpp-runtime/misc/Interval.cpp
compiling ../lib/antlr4-cpp-runtime/misc/IntervalSet.cpp
compiling ../lib/antlr4-cpp-runtime/misc/MurmurHash.cpp
compiling ../lib/antlr4-cpp-runtime/misc/Predicate.cpp
compiling ../lib/antlr4-cpp-runtime/support/Any.cpp
my_sql_parser.cpp:41070:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41070:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41070:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41076:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41076:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41076:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41090:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41090:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41090:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41096:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41096:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41096:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41110:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41110:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41110:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41116:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41116:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41116:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41125:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41125:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41125:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41131:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41131:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41131:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41140:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41140:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
my_sql_parser.cpp:41140:12: error: reference to non-static member function must be called; did you mean to call it with no arguments?
    return Qnil;
           ^~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^~~~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:33: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                ^~~~~~~
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:6: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
     ^~~~
my_sql_parser.cpp:41146:12: error: expected ')'
    return Qnil;
           ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:40: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                                       ^
my_sql_parser.cpp:41146:12: note: to match this '('
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:60:25: note: expanded from macro 'Qnil'
#define Qnil            RUBY_Qnil              /**< @old{RUBY_Qnil} */
                        ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/special_consts.h:358:21: note: expanded from macro 'RUBY_Qnil'
#define RUBY_Qnil   RBIMPL_CAST((VALUE)RUBY_Qnil)
                    ^
/opt/rubies/3.2.2/include/ruby-3.2.0/ruby/internal/cast.h:43:5: note: expanded from macro 'RBIMPL_CAST'
    (expr)                                  \
    ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
compiling ../lib/antlr4-cpp-runtime/support/Arrays.cpp
compiling ../lib/antlr4-cpp-runtime/support/CPPUtils.cpp
compiling ../lib/antlr4-cpp-runtime/support/StringUtils.cpp
compiling ../lib/antlr4-cpp-runtime/support/Utf8.cpp
../lib/antlr4-cpp-runtime/misc/IntervalSet.cpp:40:16: warning: unqualified call to 'std::move' [-Wunqualified-std-cast-call]
  _intervals = move(other._intervals);
               ^
               std::
compiling ../lib/antlr4-cpp-runtime/tree/ErrorNodeImpl.cpp
compiling ../lib/antlr4-cpp-runtime/tree/IterativeParseTreeWalker.cpp
compiling ../lib/antlr4-cpp-runtime/tree/ParseTree.cpp
compiling ../lib/antlr4-cpp-runtime/tree/ParseTreeListener.cpp
compiling ../lib/antlr4-cpp-runtime/tree/ParseTreeVisitor.cpp
1 warning generated.
compiling ../lib/antlr4-cpp-runtime/tree/ParseTreeWalker.cpp
20 errors generated.
make: *** [my_sql_parser.o] Error 1
make: *** Waiting for unfinished jobs....

my_sql_parser.cpp

#include <iostream>

#include <antlr4-runtime.h>

#include "antlrgen/MySqlParser.h"
#include "antlrgen/MySqlParserBaseVisitor.h"
#include "antlrgen/MySqlLexer.h"

#include <rice/rice.hpp>
#include <rice/stl.hpp>

#ifdef _WIN32
#undef OPTIONAL
#undef IN
#undef OUT
#endif

#undef FALSE
#undef TRUE

#undef TYPE

using namespace std;
using namespace Rice;
using namespace antlr4;

Class rb_cRootContext;
Class rb_cSqlStatementsContext;
Class rb_cSqlStatementContext;
Class rb_cEmptyStatement_Context;
Class rb_cDdlStatementContext;
Class rb_cDmlStatementContext;
Class rb_cTransactionStatementContext;
Class rb_cReplicationStatementContext;
Class rb_cPreparedStatementContext;
Class rb_cAdministrationStatementContext;
Class rb_cUtilityStatementContext;
Class rb_cCreateDatabaseContext;
Class rb_cCreateEventContext;
Class rb_cCreateIndexContext;
Class rb_cCreateLogfileGroupContext;
Class rb_cCreateProcedureContext;
Class rb_cCreateFunctionContext;
Class rb_cCreateServerContext;
Class rb_cCreateTableContext;
Class rb_cCreateTablespaceInnodbContext;
Class rb_cCreateTablespaceNdbContext;
Class rb_cCreateTriggerContext;
Class rb_cCreateViewContext;
Class rb_cCreateRoleContext;
Class rb_cAlterDatabaseContext;
Class rb_cAlterEventContext;
Class rb_cAlterFunctionContext;
Class rb_cAlterInstanceContext;
Class rb_cAlterLogfileGroupContext;
Class rb_cAlterProcedureContext;
Class rb_cAlterServerContext;
Class rb_cAlterTableContext;
Class rb_cAlterTablespaceContext;
Class rb_cAlterViewContext;
Class rb_cDropDatabaseContext;
Class rb_cDropEventContext;
Class rb_cDropIndexContext;
Class rb_cDropLogfileGroupContext;
Class rb_cDropProcedureContext;
Class rb_cDropFunctionContext;
Class rb_cDropServerContext;
Class rb_cDropTableContext;
Class rb_cDropTablespaceContext;
Class rb_cDropTriggerContext;
Class rb_cDropViewContext;
Class rb_cDropRoleContext;
Class rb_cSetRoleContext;
Class rb_cRenameTableContext;
Class rb_cTruncateTableContext;
Class rb_cSelectStatementContext;
Class rb_cInsertStatementContext;
Class rb_cUpdateStatementContext;
Class rb_cDeleteStatementContext;
Class rb_cReplaceStatementContext;
Class rb_cCallStatementContext;
Class rb_cLoadDataStatementContext;
Class rb_cLoadXmlStatementContext;
Class rb_cDoStatementContext;
Class rb_cHandlerStatementContext;
Class rb_cValuesStatementContext;
Class rb_cWithStatementContext;
Class rb_cTableStatementContext;
Class rb_cStartTransactionContext;
Class rb_cBeginWorkContext;
Class rb_cCommitWorkContext;
Class rb_cRollbackWorkContext;
Class rb_cSavepointStatementContext;
Class rb_cRollbackStatementContext;
Class rb_cReleaseStatementContext;
Class rb_cLockTablesContext;
Class rb_cUnlockTablesContext;
Class rb_cChangeMasterContext;
Class rb_cChangeReplicationFilterContext;
Class rb_cPurgeBinaryLogsContext;
Class rb_cResetMasterContext;
Class rb_cResetSlaveContext;
Class rb_cStartSlaveContext;
Class rb_cStopSlaveContext;
Class rb_cStartGroupReplicationContext;
Class rb_cStopGroupReplicationContext;
Class rb_cXaStartTransactionContext;
Class rb_cXaEndTransactionContext;
Class rb_cXaPrepareStatementContext;
Class rb_cXaCommitWorkContext;
Class rb_cXaRollbackWorkContext;
Class rb_cXaRecoverWorkContext;
Class rb_cPrepareStatementContext;
Class rb_cExecuteStatementContext;
Class rb_cDeallocatePrepareContext;
Class rb_cCompoundStatementContext;
Class rb_cBlockStatementContext;
Class rb_cCaseStatementContext;
Class rb_cIfStatementContext;
Class rb_cLeaveStatementContext;
Class rb_cLoopStatementContext;
Class rb_cRepeatStatementContext;
Class rb_cWhileStatementContext;
Class rb_cIterateStatementContext;
Class rb_cReturnStatementContext;
Class rb_cCursorStatementContext;
Class rb_cAlterUserContext;
Class rb_cCreateUserContext;
Class rb_cDropUserContext;
Class rb_cGrantStatementContext;
Class rb_cGrantProxyContext;
Class rb_cRenameUserContext;
Class rb_cRevokeStatementContext;
Class rb_cRevokeProxyContext;
Class rb_cAnalyzeTableContext;
Class rb_cCheckTableContext;
Class rb_cChecksumTableContext;
Class rb_cOptimizeTableContext;
Class rb_cRepairTableContext;
Class rb_cCreateUdfunctionContext;
Class rb_cInstallPluginContext;
Class rb_cUninstallPluginContext;
Class rb_cSetStatementContext;
Class rb_cShowStatementContext;
Class rb_cBinlogStatementContext;
Class rb_cCacheIndexStatementContext;
Class rb_cFlushStatementContext;
Class rb_cKillStatementContext;
Class rb_cLoadIndexIntoCacheContext;
Class rb_cResetStatementContext;
Class rb_cShutdownStatementContext;
Class rb_cSimpleDescribeStatementContext;
Class rb_cFullDescribeStatementContext;
Class rb_cHelpStatementContext;
Class rb_cUseStatementContext;
Class rb_cSignalStatementContext;
Class rb_cResignalStatementContext;
Class rb_cDiagnosticsStatementContext;
Class rb_cUidContext;
Class rb_cIfNotExistsContext;
Class rb_cCreateDatabaseOptionContext;
Class rb_cFullIdContext;
Class rb_cScheduleExpressionContext;
Class rb_cRoutineBodyContext;
Class rb_cOwnerStatementContext;
Class rb_cEnableTypeContext;
Class rb_cTableNameContext;
Class rb_cIndexColumnNamesContext;
Class rb_cIndexTypeContext;
Class rb_cIndexOptionContext;
Class rb_cEngineNameContext;
Class rb_cFileSizeLiteralContext;
Class rb_cProcedureParameterContext;
Class rb_cRoutineOptionContext;
Class rb_cDataTypeContext;
Class rb_cFunctionParameterContext;
Class rb_cRoleNameContext;
Class rb_cServerOptionContext;
Class rb_cCopyCreateTableContext;
Class rb_cColumnCreateTableContext;
Class rb_cCreateDefinitionsContext;
Class rb_cTableOptionContext;
Class rb_cPartitionDefinitionsContext;
Class rb_cQueryCreateTableContext;
Class rb_cWithClauseContext;
Class rb_cCommonTableExpressionsContext;
Class rb_cCteNameContext;
Class rb_cCteColumnNameContext;
Class rb_cOrReplaceContext;
Class rb_cUidListContext;
Class rb_cCharSetContext;
Class rb_cCharsetNameContext;
Class rb_cCollationNameContext;
Class rb_cCurrentUserExpressionContext;
Class rb_cUserNameContext;
Class rb_cPreciseScheduleContext;
Class rb_cTimestampValueContext;
Class rb_cIntervalExprContext;
Class rb_cIntervalScheduleContext;
Class rb_cIntervalTypeContext;
Class rb_cDecimalLiteralContext;
Class rb_cExpressionContext;
Class rb_cStringLiteralContext;
Class rb_cIntervalTypeBaseContext;
Class rb_cRoutineBehaviorContext;
Class rb_cRoutineLanguageContext;
Class rb_cRoutineCommentContext;
Class rb_cRoutineSecurityContext;
Class rb_cRoutineDataContext;
Class rb_cCreateDefinitionContext;
Class rb_cFullColumnNameContext;
Class rb_cColumnDeclarationContext;
Class rb_cColumnDefinitionContext;
Class rb_cTableConstraintContext;
Class rb_cConstraintDeclarationContext;
Class rb_cIndexColumnDefinitionContext;
Class rb_cIndexDeclarationContext;
Class rb_cColumnConstraintContext;
Class rb_cStorageColumnConstraintContext;
Class rb_cVisibilityColumnConstraintContext;
Class rb_cAutoIncrementColumnConstraintContext;
Class rb_cCurrentTimestampContext;
Class rb_cCommentColumnConstraintContext;
Class rb_cUniqueKeyColumnConstraintContext;
Class rb_cSerialDefaultColumnConstraintContext;
Class rb_cGeneratedColumnConstraintContext;
Class rb_cFormatColumnConstraintContext;
Class rb_cCollateColumnConstraintContext;
Class rb_cPrimaryKeyColumnConstraintContext;
Class rb_cCheckColumnConstraintContext;
Class rb_cNullNotnullContext;
Class rb_cNullColumnConstraintContext;
Class rb_cDefaultColumnConstraintContext;
Class rb_cDefaultValueContext;
Class rb_cReferenceDefinitionContext;
Class rb_cReferenceColumnConstraintContext;
Class rb_cInvisibilityColumnConstraintContext;
Class rb_cUniqueKeyTableConstraintContext;
Class rb_cCheckTableConstraintContext;
Class rb_cPrimaryKeyTableConstraintContext;
Class rb_cForeignKeyTableConstraintContext;
Class rb_cReferenceActionContext;
Class rb_cReferenceControlTypeContext;
Class rb_cSpecialIndexDeclarationContext;
Class rb_cSimpleIndexDeclarationContext;
Class rb_cTableOptionEngineContext;
Class rb_cTableOptionMaxRowsContext;
Class rb_cTableOptionCollateContext;
Class rb_cTableOptionPersistentContext;
Class rb_cTableOptionTablespaceContext;
Class rb_cTablespaceStorageContext;
Class rb_cTableOptionAutoextendSizeContext;
Class rb_cTableOptionPageCompressedContext;
Class rb_cTableOptionStartTransactionContext;
Class rb_cTableOptionPackKeysContext;
Class rb_cTableOptionPasswordContext;
Class rb_cTableOptionUnionContext;
Class rb_cTablesContext;
Class rb_cTableOptionSamplePageContext;
Class rb_cTableOptionCharsetContext;
Class rb_cTableOptionIndexDirectoryContext;
Class rb_cTableOptionTableTypeContext;
Class rb_cTableTypeContext;
Class rb_cTableOptionKeyBlockSizeContext;
Class rb_cTableOptionEncryptionContext;
Class rb_cTableOptionDataDirectoryContext;
Class rb_cTableOptionRecalculationContext;
Class rb_cTableOptionAutoIncrementContext;
Class rb_cTableOptionEncryptionKeyIdContext;
Class rb_cTableOptionChecksumContext;
Class rb_cTableOptionDelayContext;
Class rb_cTableOptionConnectionContext;
Class rb_cTableOptionTransactionalContext;
Class rb_cTableOptionPageCompressionLevelContext;
Class rb_cTableOptionSecondaryEngineAttributeContext;
Class rb_cTableOptionCommentContext;
Class rb_cTableOptionAverageContext;
Class rb_cTableOptionRowFormatContext;
Class rb_cTableOptionCompressionContext;
Class rb_cTableOptionInsertMethodContext;
Class rb_cTableOptionEngineAttributeContext;
Class rb_cTableOptionMinRowsContext;
Class rb_cPartitionFunctionDefinitionContext;
Class rb_cSubpartitionFunctionDefinitionContext;
Class rb_cPartitionDefinitionContext;
Class rb_cPartitionFunctionKeyContext;
Class rb_cPartitionFunctionHashContext;
Class rb_cPartitionFunctionListContext;
Class rb_cPartitionFunctionRangeContext;
Class rb_cSubPartitionFunctionHashContext;
Class rb_cSubPartitionFunctionKeyContext;
Class rb_cPartitionComparisonContext;
Class rb_cPartitionDefinerAtomContext;
Class rb_cPartitionOptionContext;
Class rb_cSubpartitionDefinitionContext;
Class rb_cPartitionListAtomContext;
Class rb_cPartitionListVectorContext;
Class rb_cPartitionDefinerVectorContext;
Class rb_cPartitionSimpleContext;
Class rb_cConstantContext;
Class rb_cPartitionOptionCommentContext;
Class rb_cPartitionOptionNodeGroupContext;
Class rb_cPartitionOptionIndexDirectoryContext;
Class rb_cPartitionOptionMaxRowsContext;
Class rb_cPartitionOptionTablespaceContext;
Class rb_cPartitionOptionEngineContext;
Class rb_cPartitionOptionMinRowsContext;
Class rb_cPartitionOptionDataDirectoryContext;
Class rb_cAlterUpgradeNameContext;
Class rb_cAlterSimpleDatabaseContext;
Class rb_cWaitNowaitClauseContext;
Class rb_cAlterSpecificationContext;
Class rb_cAlterByAlterColumnDefaultContext;
Class rb_cAlterByDisableKeysContext;
Class rb_cAlterByDefaultCharsetContext;
Class rb_cAlterByRenameColumnContext;
Class rb_cAlterByConvertCharsetContext;
Class rb_cAlterByAddForeignKeyContext;
Class rb_cAlterByRenameIndexContext;
Class rb_cAlterByRenameContext;
Class rb_cAlterByImportTablespaceContext;
Class rb_cAlterByAddDefinitionsContext;
Class rb_cAlterByAlterCheckTableConstraintContext;
Class rb_cAlterByDropConstraintCheckContext;
Class rb_cAlterByAddColumnsContext;
Class rb_cAlterByAlterIndexVisibilityContext;
Class rb_cAlterByDropForeignKeyContext;
Class rb_cAlterByAddCheckTableConstraintContext;
Class rb_cAlterPartitionSpecificationContext;
Class rb_cAlterPartitionContext;
Class rb_cAlterByAddIndexContext;
Class rb_cAlterByDropColumnContext;
Class rb_cAlterByChangeDefaultContext;
Class rb_cAlterByForceContext;
Class rb_cAlterByAddSpecialIndexContext;
Class rb_cAlterByModifyColumnContext;
Class rb_cAlterByTableOptionContext;
Class rb_cAlterByDropPrimaryKeyContext;
Class rb_cAlterByLockContext;
Class rb_cAlterByDiscardTablespaceContext;
Class rb_cAlterByValidateContext;
Class rb_cAlterByAddPrimaryKeyContext;
Class rb_cAlterByEnableKeysContext;
Class rb_cAlterBySetAlgorithmContext;
Class rb_cAlterByChangeColumnContext;
Class rb_cAlterByAddUniqueKeyContext;
Class rb_cAlterByDropIndexContext;
Class rb_cAlterByAddColumnContext;
Class rb_cAlterByOrderContext;
Class rb_cAlterByImportPartitionContext;
Class rb_cAlterByDropPartitionContext;
Class rb_cAlterByDiscardPartitionContext;
Class rb_cAlterByAddPartitionContext;
Class rb_cAlterByRemovePartitioningContext;
Class rb_cAlterByOptimizePartitionContext;
Class rb_cAlterByCheckPartitionContext;
Class rb_cAlterByCoalescePartitionContext;
Class rb_cAlterByReorganizePartitionContext;
Class rb_cAlterByAnalyzePartitionContext;
Class rb_cAlterByRebuildPartitionContext;
Class rb_cAlterByUpgradePartitioningContext;
Class rb_cAlterByTruncatePartitionContext;
Class rb_cAlterByRepairPartitionContext;
Class rb_cAlterByExchangePartitionContext;
Class rb_cIfExistsContext;
Class rb_cRoleOptionContext;
Class rb_cRenameTableClauseContext;
Class rb_cConstantsContext;
Class rb_cExpressionsContext;
Class rb_cSingleDeleteStatementContext;
Class rb_cMultipleDeleteStatementContext;
Class rb_cHandlerOpenStatementContext;
Class rb_cHandlerReadIndexStatementContext;
Class rb_cHandlerReadStatementContext;
Class rb_cHandlerCloseStatementContext;
Class rb_cInsertStatementValueContext;
Class rb_cUpdatedElementContext;
Class rb_cFullColumnNameListContext;
Class rb_cAssignmentFieldContext;
Class rb_cSelectFieldsIntoContext;
Class rb_cSelectLinesIntoContext;
Class rb_cQuerySpecificationNointoContext;
Class rb_cUnionSelectContext;
Class rb_cQueryExpressionNointoContext;
Class rb_cUnionStatementContext;
Class rb_cOrderByClauseContext;
Class rb_cLimitClauseContext;
Class rb_cLockClauseContext;
Class rb_cQuerySpecificationContext;
Class rb_cQueryExpressionContext;
Class rb_cUnionParenthesisSelectContext;
Class rb_cUnionParenthesisContext;
Class rb_cSimpleSelectContext;
Class rb_cParenthesisSelectContext;
Class rb_cWithLateralStatementContext;
Class rb_cLateralStatementContext;
Class rb_cSingleUpdateStatementContext;
Class rb_cMultipleUpdateStatementContext;
Class rb_cExpressionsWithDefaultsContext;
Class rb_cLimitClauseAtomContext;
Class rb_cTableSourcesContext;
Class rb_cComparisonOperatorContext;
Class rb_cOrderByExpressionContext;
Class rb_cTableSourceContext;
Class rb_cJsonTableContext;
Class rb_cTableJsonContext;
Class rb_cTableSourceNestedContext;
Class rb_cTableSourceItemContext;
Class rb_cJoinPartContext;
Class rb_cTableSourceBaseContext;
Class rb_cSubqueryTableItemContext;
Class rb_cAtomTableItemContext;
Class rb_cIndexHintContext;
Class rb_cTableSourcesItemContext;
Class rb_cIndexHintTypeContext;
Class rb_cInnerJoinContext;
Class rb_cJoinSpecContext;
Class rb_cNaturalJoinContext;
Class rb_cOuterJoinContext;
Class rb_cStraightJoinContext;
Class rb_cSelectElementsContext;
Class rb_cFromClauseContext;
Class rb_cSelectSpecContext;
Class rb_cSelectIntoExpressionContext;
Class rb_cGroupByClauseContext;
Class rb_cHavingClauseContext;
Class rb_cWindowClauseContext;
Class rb_cJsonColumnListContext;
Class rb_cJsonColumnContext;
Class rb_cJsonOnEmptyContext;
Class rb_cJsonOnErrorContext;
Class rb_cSelectElementContext;
Class rb_cSelectExpressionElementContext;
Class rb_cFunctionCallContext;
Class rb_cSelectFunctionElementContext;
Class rb_cSelectStarElementContext;
Class rb_cSelectColumnElementContext;
Class rb_cSelectIntoVariablesContext;
Class rb_cSelectIntoTextFileContext;
Class rb_cSelectIntoDumpFileContext;
Class rb_cGroupByItemContext;
Class rb_cWindowNameContext;
Class rb_cWindowSpecContext;
Class rb_cMysqlVariableContext;
Class rb_cSimpleIdContext;
Class rb_cTransactionModeContext;
Class rb_cLockTableElementContext;
Class rb_cSetAutocommitStatementContext;
Class rb_cSetTransactionStatementContext;
Class rb_cTransactionOptionContext;
Class rb_cLockActionContext;
Class rb_cTransactionLevelContext;
Class rb_cMasterOptionContext;
Class rb_cChannelOptionContext;
Class rb_cReplicationFilterContext;
Class rb_cThreadTypeContext;
Class rb_cUntilOptionContext;
Class rb_cConnectionOptionContext;
Class rb_cStringMasterOptionContext;
Class rb_cMasterStringOptionContext;
Class rb_cMasterRealOptionContext;
Class rb_cBoolMasterOptionContext;
Class rb_cMasterBoolOptionContext;
Class rb_cMasterUidListOptionContext;
Class rb_cDecimalMasterOptionContext;
Class rb_cMasterDecimalOptionContext;
Class rb_cWildIgnoreTableReplicationContext;
Class rb_cSimpleStringsContext;
Class rb_cDoTableReplicationContext;
Class rb_cIgnoreTableReplicationContext;
Class rb_cRewriteDbReplicationContext;
Class rb_cTablePairContext;
Class rb_cDoDbReplicationContext;
Class rb_cIgnoreDbReplicationContext;
Class rb_cWildDoTableReplicationContext;
Class rb_cGtidsUntilOptionContext;
Class rb_cGtuidSetContext;
Class rb_cSqlGapsUntilOptionContext;
Class rb_cMasterLogUntilOptionContext;
Class rb_cRelayLogUntilOptionContext;
Class rb_cPluginDirConnectionOptionContext;
Class rb_cUserConnectionOptionContext;
Class rb_cDefaultAuthConnectionOptionContext;
Class rb_cPasswordConnectionOptionContext;
Class rb_cUuidSetContext;
Class rb_cXidContext;
Class rb_cUserVariablesContext;
Class rb_cDeclareVariableContext;
Class rb_cDeclareConditionContext;
Class rb_cDeclareCursorContext;
Class rb_cDeclareHandlerContext;
Class rb_cProcedureSqlStatementContext;
Class rb_cCaseAlternativeContext;
Class rb_cElifAlternativeContext;
Class rb_cCloseCursorContext;
Class rb_cOpenCursorContext;
Class rb_cFetchCursorContext;
Class rb_cHandlerConditionValueContext;
Class rb_cHandlerConditionWarningContext;
Class rb_cHandlerConditionCodeContext;
Class rb_cHandlerConditionNotfoundContext;
Class rb_cHandlerConditionStateContext;
Class rb_cHandlerConditionExceptionContext;
Class rb_cHandlerConditionNameContext;
Class rb_cAlterUserMysqlV80Context;
Class rb_cUserAuthOptionContext;
Class rb_cUserPasswordOptionContext;
Class rb_cUserLockOptionContext;
Class rb_cTlsOptionContext;
Class rb_cUserResourceOptionContext;
Class rb_cAlterUserMysqlV56Context;
Class rb_cUserSpecificationContext;
Class rb_cCreateUserMysqlV56Context;
Class rb_cCreateUserMysqlV80Context;
Class rb_cPrivelegeClauseContext;
Class rb_cPrivilegeLevelContext;
Class rb_cRenameUserClauseContext;
Class rb_cDetailRevokeContext;
Class rb_cRoleRevokeContext;
Class rb_cShortRevokeContext;
Class rb_cSetPasswordStatementContext;
Class rb_cPasswordFunctionClauseContext;
Class rb_cSimpleAuthOptionContext;
Class rb_cModuleAuthOptionContext;
Class rb_cAuthenticationRuleContext;
Class rb_cRandomAuthOptionContext;
Class rb_cAuthOptionClauseContext;
Class rb_cStringAuthOptionContext;
Class rb_cHashAuthOptionContext;
Class rb_cAuthPluginContext;
Class rb_cPasswordModuleOptionContext;
Class rb_cModuleContext;
Class rb_cPrivilegeContext;
Class rb_cDefiniteSchemaPrivLevelContext;
Class rb_cDefiniteFullTablePrivLevel2Context;
Class rb_cDottedIdContext;
Class rb_cDefiniteFullTablePrivLevelContext;
Class rb_cGlobalPrivLevelContext;
Class rb_cDefiniteTablePrivLevelContext;
Class rb_cCurrentSchemaPriviLevelContext;
Class rb_cCheckTableOptionContext;
Class rb_cSetTransactionContext;
Class rb_cSetCharsetContext;
Class rb_cSetNamesContext;
Class rb_cSetPasswordContext;
Class rb_cSetAutocommitContext;
Class rb_cSetNewValueInsideTriggerContext;
Class rb_cSetVariableContext;
Class rb_cVariableClauseContext;
Class rb_cShowOpenTablesContext;
Class rb_cShowFilterContext;
Class rb_cShowGlobalInfoContext;
Class rb_cShowGlobalInfoClauseContext;
Class rb_cShowCreateFullIdObjectContext;
Class rb_cShowCreateUserContext;
Class rb_cShowErrorsContext;
Class rb_cShowCountErrorsContext;
Class rb_cShowObjectFilterContext;
Class rb_cShowCommonEntityContext;
Class rb_cShowCreateDbContext;
Class rb_cShowEngineContext;
Class rb_cShowSchemaFilterContext;
Class rb_cShowSchemaEntityContext;
Class rb_cShowIndexesContext;
Class rb_cShowLogEventsContext;
Class rb_cShowMasterLogsContext;
Class rb_cShowGrantsContext;
Class rb_cShowSlaveStatusContext;
Class rb_cShowRoutineContext;
Class rb_cShowProfileContext;
Class rb_cShowProfileTypeContext;
Class rb_cShowColumnsContext;
Class rb_cTableIndexesContext;
Class rb_cFlushOptionContext;
Class rb_cLoadedTableIndexesContext;
Class rb_cTableFlushOptionContext;
Class rb_cFlushTableOptionContext;
Class rb_cChannelFlushOptionContext;
Class rb_cSimpleFlushOptionContext;
Class rb_cDescribeObjectClauseContext;
Class rb_cSignalConditionInformationContext;
Class rb_cDiagnosticsConditionInformationNameContext;
Class rb_cDescribeStatementsContext;
Class rb_cDescribeConnectionContext;
Class rb_cIndexColumnNameContext;
Class rb_cSimpleUserNameContext;
Class rb_cKeywordsCanBeIdContext;
Class rb_cHostNameContext;
Class rb_cCharsetNameBaseContext;
Class rb_cEngineNameBaseContext;
Class rb_cXuidStringIdContext;
Class rb_cTransactionLevelBaseContext;
Class rb_cPrivilegesBaseContext;
Class rb_cDataTypeBaseContext;
Class rb_cScalarFunctionNameContext;
Class rb_cBooleanLiteralContext;
Class rb_cHexadecimalLiteralContext;
Class rb_cSpatialDataTypeContext;
Class rb_cLongVarbinaryDataTypeContext;
Class rb_cCollectionOptionsContext;
Class rb_cCollectionDataTypeContext;
Class rb_cNationalVaryingStringDataTypeContext;
Class rb_cLengthOneDimensionContext;
Class rb_cDimensionDataTypeContext;
Class rb_cLengthTwoDimensionContext;
Class rb_cLengthTwoOptionalDimensionContext;
Class rb_cStringDataTypeContext;
Class rb_cLongVarcharDataTypeContext;
Class rb_cNationalStringDataTypeContext;
Class rb_cSimpleDataTypeContext;
Class rb_cConvertedDataTypeContext;
Class rb_cExpressionOrDefaultContext;
Class rb_cUnaryOperatorContext;
Class rb_cSpecificFunctionContext;
Class rb_cSpecificFunctionCallContext;
Class rb_cPasswordFunctionCallContext;
Class rb_cUdfFunctionCallContext;
Class rb_cFunctionArgsContext;
Class rb_cNonAggregateWindowedFunctionContext;
Class rb_cNonAggregateFunctionCallContext;
Class rb_cAggregateWindowedFunctionContext;
Class rb_cAggregateFunctionCallContext;
Class rb_cScalarFunctionCallContext;
Class rb_cPositionFunctionCallContext;
Class rb_cTrimFunctionCallContext;
Class rb_cJsonValueFunctionCallContext;
Class rb_cCaseFunctionCallContext;
Class rb_cCaseFuncAlternativeContext;
Class rb_cFunctionArgContext;
Class rb_cExtractFunctionCallContext;
Class rb_cDataTypeFunctionCallContext;
Class rb_cValuesFunctionCallContext;
Class rb_cCaseExpressionFunctionCallContext;
Class rb_cCurrentUserContext;
Class rb_cSimpleFunctionCallContext;
Class rb_cCharFunctionCallContext;
Class rb_cWeightFunctionCallContext;
Class rb_cLevelsInWeightStringContext;
Class rb_cGetFormatFunctionCallContext;
Class rb_cSubstrFunctionCallContext;
Class rb_cLevelWeightRangeContext;
Class rb_cLevelWeightListContext;
Class rb_cLevelInWeightListElementContext;
Class rb_cOverClauseContext;
Class rb_cPartitionClauseContext;
Class rb_cFrameClauseContext;
Class rb_cFrameUnitsContext;
Class rb_cFrameExtentContext;
Class rb_cFrameRangeContext;
Class rb_cFrameBetweenContext;
Class rb_cFunctionNameBaseContext;
Class rb_cPredicateContext;
Class rb_cIsExpressionContext;
Class rb_cNotExpressionContext;
Class rb_cLogicalExpressionContext;
Class rb_cLogicalOperatorContext;
Class rb_cPredicateExpressionContext;
Class rb_cSoundsLikePredicateContext;
Class rb_cExpressionAtomContext;
Class rb_cExpressionAtomPredicateContext;
Class rb_cSubqueryComparisonPredicateContext;
Class rb_cJsonMemberOfPredicateContext;
Class rb_cBinaryComparisonPredicateContext;
Class rb_cInPredicateContext;
Class rb_cBetweenPredicateContext;
Class rb_cIsNullPredicateContext;
Class rb_cLikePredicateContext;
Class rb_cRegexpPredicateContext;
Class rb_cUnaryExpressionAtomContext;
Class rb_cCollateExpressionAtomContext;
Class rb_cVariableAssignExpressionAtomContext;
Class rb_cMysqlVariableExpressionAtomContext;
Class rb_cNestedExpressionAtomContext;
Class rb_cNestedRowExpressionAtomContext;
Class rb_cMultOperatorContext;
Class rb_cMathExpressionAtomContext;
Class rb_cAddOperatorContext;
Class rb_cExistsExpressionAtomContext;
Class rb_cIntervalExpressionAtomContext;
Class rb_cJsonOperatorContext;
Class rb_cJsonExpressionAtomContext;
Class rb_cSubqueryExpressionAtomContext;
Class rb_cConstantExpressionAtomContext;
Class rb_cFunctionCallExpressionAtomContext;
Class rb_cBinaryExpressionAtomContext;
Class rb_cFullColumnNameExpressionAtomContext;
Class rb_cBitOperatorContext;
Class rb_cBitExpressionAtomContext;
Class rb_cToken;
Class rb_cParser;
Class rb_cParseTree;
Class rb_cTerminalNode;
Class rb_cContextProxy;

namespace Rice::detail {
  template <>
  class To_Ruby<Token*> {
  public:
    VALUE convert(Token* const &x) {
      if (!x) return Nil;
      return Data_Object<Token>(x, false, rb_cToken);
    }
  };

  template <>
  class To_Ruby<tree::ParseTree*> {
  public:
    VALUE convert(tree::ParseTree* const &x) {
      if (!x) return Nil;
      return Data_Object<tree::ParseTree>(x, false, rb_cParseTree);
    }
  };

  template <>
  class To_Ruby<tree::TerminalNode*> {
  public:
    VALUE convert(tree::TerminalNode* const &x) {
      if (!x) return Nil;
      return Data_Object<tree::TerminalNode>(x, false, rb_cTerminalNode);
    }
  };
}

class ContextProxy {
public:
  ContextProxy(tree::ParseTree* orig) {
    this -> orig = orig;
  }

  tree::ParseTree* getOriginal() {
    return orig;
  }

  std::string getText() {
    return orig -> getText();
  }

  Object getStart() {
    auto token = ((ParserRuleContext*) orig) -> getStart();

    return detail::To_Ruby<Token*>().convert(token);
  }

  Object getStop() {
    auto token = ((ParserRuleContext*) orig) -> getStop();

    return detail::To_Ruby<Token*>().convert(token);
  }

  Array getChildren() {
    Array children;
    if (orig != nullptr) {
      for (auto it = orig -> children.begin(); it != orig -> children.end(); it ++) {
        Object parseTree = ContextProxy::wrapParseTree(*it);

        if (parseTree != Nil) {
          children.push(parseTree);
        }
      }
    }
    return children;
  }

  Object getParent() {
    return orig == nullptr ? Nil : ContextProxy::wrapParseTree(orig -> parent);
  }

  size_t childCount() {
    return orig == nullptr ? 0 : orig -> children.size();
  }

  bool doubleEquals(Object other) {
    if (other.is_a(rb_cContextProxy)) {
      return detail::From_Ruby<ContextProxy*>().convert(other) -> getOriginal() == getOriginal();
    } else {
      return false;
    }
  }

private:

  static Object wrapParseTree(tree::ParseTree* node);

protected:
  tree::ParseTree* orig = nullptr;
};

class TerminalNodeProxy : public ContextProxy {
public:
  TerminalNodeProxy(tree::ParseTree* tree) : ContextProxy(tree) { }
};


class RootContextProxy : public ContextProxy {
public:
  RootContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object sqlStatements();
  Object EOF();
  Object MINUS();
  Object MINUSAt(size_t i);
};

class SqlStatementsContextProxy : public ContextProxy {
public:
  SqlStatementsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object sqlStatement();
  Object sqlStatementAt(size_t i);
  Object emptyStatement_();
  Object emptyStatement_At(size_t i);
  Object SEMI();
  Object SEMIAt(size_t i);
  Object MINUS();
  Object MINUSAt(size_t i);
};

class SqlStatementContextProxy : public ContextProxy {
public:
  SqlStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object ddlStatement();
  Object dmlStatement();
  Object transactionStatement();
  Object replicationStatement();
  Object preparedStatement();
  Object administrationStatement();
  Object utilityStatement();

};

class EmptyStatement_ContextProxy : public ContextProxy {
public:
  EmptyStatement_ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SEMI();
};

class DdlStatementContextProxy : public ContextProxy {
public:
  DdlStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object createDatabase();
  Object createEvent();
  Object createIndex();
  Object createLogfileGroup();
  Object createProcedure();
  Object createFunction();
  Object createServer();
  Object createTable();
  Object createTablespaceInnodb();
  Object createTablespaceNdb();
  Object createTrigger();
  Object createView();
  Object createRole();
  Object alterDatabase();
  Object alterEvent();
  Object alterFunction();
  Object alterInstance();
  Object alterLogfileGroup();
  Object alterProcedure();
  Object alterServer();
  Object alterTable();
  Object alterTablespace();
  Object alterView();
  Object dropDatabase();
  Object dropEvent();
  Object dropIndex();
  Object dropLogfileGroup();
  Object dropProcedure();
  Object dropFunction();
  Object dropServer();
  Object dropTable();
  Object dropTablespace();
  Object dropTrigger();
  Object dropView();
  Object dropRole();
  Object setRole();
  Object renameTable();
  Object truncateTable();

};

class DmlStatementContextProxy : public ContextProxy {
public:
  DmlStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectStatement();
  Object insertStatement();
  Object updateStatement();
  Object deleteStatement();
  Object replaceStatement();
  Object callStatement();
  Object loadDataStatement();
  Object loadXmlStatement();
  Object doStatement();
  Object handlerStatement();
  Object valuesStatement();
  Object withStatement();
  Object tableStatement();

};

class TransactionStatementContextProxy : public ContextProxy {
public:
  TransactionStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object startTransaction();
  Object beginWork();
  Object commitWork();
  Object rollbackWork();
  Object savepointStatement();
  Object rollbackStatement();
  Object releaseStatement();
  Object lockTables();
  Object unlockTables();

};

class ReplicationStatementContextProxy : public ContextProxy {
public:
  ReplicationStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object changeMaster();
  Object changeReplicationFilter();
  Object purgeBinaryLogs();
  Object resetMaster();
  Object resetSlave();
  Object startSlave();
  Object stopSlave();
  Object startGroupReplication();
  Object stopGroupReplication();
  Object xaStartTransaction();
  Object xaEndTransaction();
  Object xaPrepareStatement();
  Object xaCommitWork();
  Object xaRollbackWork();
  Object xaRecoverWork();

};

class PreparedStatementContextProxy : public ContextProxy {
public:
  PreparedStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object prepareStatement();
  Object executeStatement();
  Object deallocatePrepare();

};

class AdministrationStatementContextProxy : public ContextProxy {
public:
  AdministrationStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object alterUser();
  Object createUser();
  Object dropUser();
  Object grantStatement();
  Object grantProxy();
  Object renameUser();
  Object revokeStatement();
  Object revokeProxy();
  Object analyzeTable();
  Object checkTable();
  Object checksumTable();
  Object optimizeTable();
  Object repairTable();
  Object createUdfunction();
  Object installPlugin();
  Object uninstallPlugin();
  Object setStatement();
  Object showStatement();
  Object binlogStatement();
  Object cacheIndexStatement();
  Object flushStatement();
  Object killStatement();
  Object loadIndexIntoCache();
  Object resetStatement();
  Object shutdownStatement();

};

class UtilityStatementContextProxy : public ContextProxy {
public:
  UtilityStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object simpleDescribeStatement();
  Object fullDescribeStatement();
  Object helpStatement();
  Object useStatement();
  Object signalStatement();
  Object resignalStatement();
  Object diagnosticsStatement();

};

class CreateDatabaseContextProxy : public ContextProxy {
public:
  CreateDatabaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ifNotExists();
  Object createDatabaseOption();
  Object createDatabaseOptionAt(size_t i);
  Object CREATE();
  Object DATABASE();
  Object SCHEMA();
};

class CreateEventContextProxy : public ContextProxy {
public:
  CreateEventContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object scheduleExpression();
  Object routineBody();
  Object ownerStatement();
  Object ifNotExists();
  Object enableType();
  Object CREATE();
  Object EVENT();
  Object ON();
  Object ONAt(size_t i);
  Object SCHEDULE();
  Object DO();
  Object COMPLETION();
  Object PRESERVE();
  Object COMMENT();
  Object STRING_LITERAL();
  Object NOT();
};

class CreateIndexContextProxy : public ContextProxy {
public:
  CreateIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object tableName();
  Object indexColumnNames();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object CREATE();
  Object INDEX();
  Object ON();
  Object ALGORITHM();
  Object ALGORITHMAt(size_t i);
  Object LOCK();
  Object LOCKAt(size_t i);
  Object ONLINE();
  Object OFFLINE();
  Object UNIQUE();
  Object FULLTEXT();
  Object SPATIAL();
  Object DEFAULT();
  Object DEFAULTAt(size_t i);
  Object INPLACE();
  Object INPLACEAt(size_t i);
  Object COPY();
  Object COPYAt(size_t i);
  Object NONE();
  Object NONEAt(size_t i);
  Object SHARED();
  Object SHAREDAt(size_t i);
  Object EXCLUSIVE();
  Object EXCLUSIVEAt(size_t i);
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
};

class CreateLogfileGroupContextProxy : public ContextProxy {
public:
  CreateLogfileGroupContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object engineName();
  Object fileSizeLiteral();
  Object fileSizeLiteralAt(size_t i);
  Object CREATE();
  Object LOGFILE();
  Object GROUP();
  Object ADD();
  Object UNDOFILE();
  Object ENGINE();
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object INITIAL_SIZE();
  Object UNDO_BUFFER_SIZE();
  Object REDO_BUFFER_SIZE();
  Object NODEGROUP();
  Object WAIT();
  Object COMMENT();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
};

class CreateProcedureContextProxy : public ContextProxy {
public:
  CreateProcedureContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object routineBody();
  Object ownerStatement();
  Object procedureParameter();
  Object procedureParameterAt(size_t i);
  Object routineOption();
  Object routineOptionAt(size_t i);
  Object CREATE();
  Object PROCEDURE();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CreateFunctionContextProxy : public ContextProxy {
public:
  CreateFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object dataType();
  Object routineBody();
  Object returnStatement();
  Object ownerStatement();
  Object ifNotExists();
  Object functionParameter();
  Object functionParameterAt(size_t i);
  Object routineOption();
  Object routineOptionAt(size_t i);
  Object CREATE();
  Object FUNCTION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object RETURNS();
  Object AGGREGATE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CreateServerContextProxy : public ContextProxy {
public:
  CreateServerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object serverOption();
  Object serverOptionAt(size_t i);
  Object CREATE();
  Object SERVER();
  Object FOREIGN();
  Object DATA();
  Object WRAPPER();
  Object OPTIONS();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object MYSQL();
  Object STRING_LITERAL();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CreateTableContextProxy : public ContextProxy {
public:
  CreateTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class CreateTablespaceInnodbContextProxy : public ContextProxy {
public:
  CreateTablespaceInnodbContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object engineName();
  Object fileSizeLiteral();
  Object CREATE();
  Object TABLESPACE();
  Object ADD();
  Object DATAFILE();
  Object STRING_LITERAL();
  Object FILE_BLOCK_SIZE();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object ENGINE();
};

class CreateTablespaceNdbContextProxy : public ContextProxy {
public:
  CreateTablespaceNdbContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object engineName();
  Object fileSizeLiteral();
  Object fileSizeLiteralAt(size_t i);
  Object CREATE();
  Object TABLESPACE();
  Object ADD();
  Object DATAFILE();
  Object USE();
  Object LOGFILE();
  Object GROUP();
  Object ENGINE();
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object EXTENT_SIZE();
  Object INITIAL_SIZE();
  Object AUTOEXTEND_SIZE();
  Object MAX_SIZE();
  Object NODEGROUP();
  Object WAIT();
  Object COMMENT();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
};

class CreateTriggerContextProxy : public ContextProxy {
public:
  CreateTriggerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object routineBody();
  Object fullId();
  Object fullIdAt(size_t i);
  Object ownerStatement();
  Object CREATE();
  Object TRIGGER();
  Object ON();
  Object FOR();
  Object EACH();
  Object ROW();
  Object BEFORE();
  Object AFTER();
  Object INSERT();
  Object UPDATE();
  Object DELETE();
  Object FOLLOWS();
  Object PRECEDES();
};

class CreateViewContextProxy : public ContextProxy {
public:
  CreateViewContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object selectStatement();
  Object orReplace();
  Object ownerStatement();
  Object uidList();
  Object withClause();
  Object CREATE();
  Object VIEW();
  Object AS();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object ALGORITHM();
  Object EQUAL_SYMBOL();
  Object SQL();
  Object SECURITY();
  Object UNDEFINED();
  Object MERGE();
  Object TEMPTABLE();
  Object DEFINER();
  Object INVOKER();
  Object WITH();
  Object CHECK();
  Object OPTION();
  Object CASCADED();
  Object LOCAL();
};

class CreateRoleContextProxy : public ContextProxy {
public:
  CreateRoleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object roleName();
  Object roleNameAt(size_t i);
  Object ifNotExists();
  Object CREATE();
  Object ROLE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterDatabaseContextProxy : public ContextProxy {
public:
  AlterDatabaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class AlterEventContextProxy : public ContextProxy {
public:
  AlterEventContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object fullIdAt(size_t i);
  Object ownerStatement();
  Object scheduleExpression();
  Object enableType();
  Object routineBody();
  Object ALTER();
  Object EVENT();
  Object ON();
  Object ONAt(size_t i);
  Object SCHEDULE();
  Object COMPLETION();
  Object PRESERVE();
  Object RENAME();
  Object TO();
  Object COMMENT();
  Object STRING_LITERAL();
  Object DO();
  Object NOT();
};

class AlterFunctionContextProxy : public ContextProxy {
public:
  AlterFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object routineOption();
  Object routineOptionAt(size_t i);
  Object ALTER();
  Object FUNCTION();
};

class AlterInstanceContextProxy : public ContextProxy {
public:
  AlterInstanceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ALTER();
  Object INSTANCE();
  Object ROTATE();
  Object INNODB();
  Object MASTER();
  Object KEY();
};

class AlterLogfileGroupContextProxy : public ContextProxy {
public:
  AlterLogfileGroupContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object engineName();
  Object fileSizeLiteral();
  Object ALTER();
  Object LOGFILE();
  Object GROUP();
  Object ADD();
  Object UNDOFILE();
  Object STRING_LITERAL();
  Object ENGINE();
  Object INITIAL_SIZE();
  Object WAIT();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
};

class AlterProcedureContextProxy : public ContextProxy {
public:
  AlterProcedureContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object routineOption();
  Object routineOptionAt(size_t i);
  Object ALTER();
  Object PROCEDURE();
};

class AlterServerContextProxy : public ContextProxy {
public:
  AlterServerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object serverOption();
  Object serverOptionAt(size_t i);
  Object ALTER();
  Object SERVER();
  Object OPTIONS();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterTableContextProxy : public ContextProxy {
public:
  AlterTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object waitNowaitClause();
  Object alterSpecification();
  Object alterSpecificationAt(size_t i);
  Object partitionDefinitions();
  Object ALTER();
  Object TABLE();
  Object IGNORE();
  Object ONLINE();
  Object OFFLINE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterTablespaceContextProxy : public ContextProxy {
public:
  AlterTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object engineName();
  Object fileSizeLiteral();
  Object ALTER();
  Object TABLESPACE();
  Object DATAFILE();
  Object STRING_LITERAL();
  Object ENGINE();
  Object ADD();
  Object DROP();
  Object INITIAL_SIZE();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object WAIT();
};

class AlterViewContextProxy : public ContextProxy {
public:
  AlterViewContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object selectStatement();
  Object ownerStatement();
  Object uidList();
  Object ALTER();
  Object VIEW();
  Object AS();
  Object ALGORITHM();
  Object EQUAL_SYMBOL();
  Object SQL();
  Object SECURITY();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object WITH();
  Object CHECK();
  Object OPTION();
  Object UNDEFINED();
  Object MERGE();
  Object TEMPTABLE();
  Object DEFINER();
  Object INVOKER();
  Object CASCADED();
  Object LOCAL();
};

class DropDatabaseContextProxy : public ContextProxy {
public:
  DropDatabaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ifExists();
  Object DROP();
  Object DATABASE();
  Object SCHEMA();
};

class DropEventContextProxy : public ContextProxy {
public:
  DropEventContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object ifExists();
  Object DROP();
  Object EVENT();
};

class DropIndexContextProxy : public ContextProxy {
public:
  DropIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object tableName();
  Object DROP();
  Object INDEX();
  Object ON();
  Object ALGORITHM();
  Object ALGORITHMAt(size_t i);
  Object LOCK();
  Object LOCKAt(size_t i);
  Object ONLINE();
  Object OFFLINE();
  Object DEFAULT();
  Object DEFAULTAt(size_t i);
  Object INPLACE();
  Object INPLACEAt(size_t i);
  Object COPY();
  Object COPYAt(size_t i);
  Object NONE();
  Object NONEAt(size_t i);
  Object SHARED();
  Object SHAREDAt(size_t i);
  Object EXCLUSIVE();
  Object EXCLUSIVEAt(size_t i);
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
};

class DropLogfileGroupContextProxy : public ContextProxy {
public:
  DropLogfileGroupContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object engineName();
  Object DROP();
  Object LOGFILE();
  Object GROUP();
  Object ENGINE();
  Object EQUAL_SYMBOL();
};

class DropProcedureContextProxy : public ContextProxy {
public:
  DropProcedureContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object ifExists();
  Object DROP();
  Object PROCEDURE();
};

class DropFunctionContextProxy : public ContextProxy {
public:
  DropFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object ifExists();
  Object DROP();
  Object FUNCTION();
};

class DropServerContextProxy : public ContextProxy {
public:
  DropServerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ifExists();
  Object DROP();
  Object SERVER();
};

class DropTableContextProxy : public ContextProxy {
public:
  DropTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object ifExists();
  Object DROP();
  Object TABLE();
  Object TEMPORARY();
  Object RESTRICT();
  Object CASCADE();
};

class DropTablespaceContextProxy : public ContextProxy {
public:
  DropTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object engineName();
  Object DROP();
  Object TABLESPACE();
  Object ENGINE();
  Object EQUAL_SYMBOL();
};

class DropTriggerContextProxy : public ContextProxy {
public:
  DropTriggerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object ifExists();
  Object DROP();
  Object TRIGGER();
};

class DropViewContextProxy : public ContextProxy {
public:
  DropViewContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object fullIdAt(size_t i);
  Object ifExists();
  Object DROP();
  Object VIEW();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object RESTRICT();
  Object CASCADE();
};

class DropRoleContextProxy : public ContextProxy {
public:
  DropRoleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object roleName();
  Object roleNameAt(size_t i);
  Object ifExists();
  Object DROP();
  Object ROLE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class SetRoleContextProxy : public ContextProxy {
public:
  SetRoleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object roleName();
  Object roleNameAt(size_t i);
  Object userName();
  Object userNameAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object roleOption();
  Object SET();
  Object DEFAULT();
  Object ROLE();
  Object TO();
  Object NONE();
  Object ALL();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class RenameTableContextProxy : public ContextProxy {
public:
  RenameTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object renameTableClause();
  Object renameTableClauseAt(size_t i);
  Object RENAME();
  Object TABLE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class TruncateTableContextProxy : public ContextProxy {
public:
  TruncateTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object TRUNCATE();
  Object TABLE();
};

class SelectStatementContextProxy : public ContextProxy {
public:
  SelectStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class InsertStatementContextProxy : public ContextProxy {
public:
  InsertStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object insertStatementValue();
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object uid();
  Object uidList();
  Object fullColumnNameList();
  Object INSERT();
  Object SET();
  Object IGNORE();
  Object INTO();
  Object PARTITION();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object ON();
  Object DUPLICATE();
  Object KEY();
  Object UPDATE();
  Object LOW_PRIORITY();
  Object DELAYED();
  Object HIGH_PRIORITY();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object AS();
};

class UpdateStatementContextProxy : public ContextProxy {
public:
  UpdateStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object singleUpdateStatement();
  Object multipleUpdateStatement();

};

class DeleteStatementContextProxy : public ContextProxy {
public:
  DeleteStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object singleDeleteStatement();
  Object multipleDeleteStatement();

};

class ReplaceStatementContextProxy : public ContextProxy {
public:
  ReplaceStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object insertStatementValue();
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object uidList();
  Object uidListAt(size_t i);
  Object REPLACE();
  Object SET();
  Object INTO();
  Object PARTITION();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object LOW_PRIORITY();
  Object DELAYED();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CallStatementContextProxy : public ContextProxy {
public:
  CallStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object constants();
  Object expressions();
  Object CALL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class LoadDataStatementContextProxy : public ContextProxy {
public:
  LoadDataStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uidList();
  Object decimalLiteral();
  Object assignmentField();
  Object assignmentFieldAt(size_t i);
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object charsetName();
  Object selectFieldsInto();
  Object selectFieldsIntoAt(size_t i);
  Object selectLinesInto();
  Object selectLinesIntoAt(size_t i);
  Object LOAD();
  Object DATA();
  Object INFILE();
  Object INTO();
  Object TABLE();
  Object STRING_LITERAL();
  Object LOCAL();
  Object PARTITION();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object CHARACTER();
  Object SET();
  Object SETAt(size_t i);
  Object LINES();
  Object LINESAt(size_t i);
  Object IGNORE();
  Object IGNOREAt(size_t i);
  Object LOW_PRIORITY();
  Object CONCURRENT();
  Object REPLACE();
  Object FIELDS();
  Object COLUMNS();
  Object ROWS();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class LoadXmlStatementContextProxy : public ContextProxy {
public:
  LoadXmlStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object decimalLiteral();
  Object assignmentField();
  Object assignmentFieldAt(size_t i);
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object charsetName();
  Object LOAD();
  Object XML();
  Object INFILE();
  Object INTO();
  Object TABLE();
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object LOCAL();
  Object CHARACTER();
  Object SET();
  Object SETAt(size_t i);
  Object ROWS();
  Object ROWSAt(size_t i);
  Object IDENTIFIED();
  Object BY();
  Object LESS_SYMBOL();
  Object GREATER_SYMBOL();
  Object IGNORE();
  Object IGNOREAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LOW_PRIORITY();
  Object CONCURRENT();
  Object REPLACE();
  Object LINES();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class DoStatementContextProxy : public ContextProxy {
public:
  DoStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressions();
  Object DO();
};

class HandlerStatementContextProxy : public ContextProxy {
public:
  HandlerStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object handlerOpenStatement();
  Object handlerReadIndexStatement();
  Object handlerReadStatement();
  Object handlerCloseStatement();

};

class ValuesStatementContextProxy : public ContextProxy {
public:
  ValuesStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionsWithDefaults();
  Object expressionsWithDefaultsAt(size_t i);
  Object VALUES();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class WithStatementContextProxy : public ContextProxy {
public:
  WithStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object commonTableExpressions();
  Object commonTableExpressionsAt(size_t i);
  Object WITH();
  Object RECURSIVE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class TableStatementContextProxy : public ContextProxy {
public:
  TableStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object orderByClause();
  Object limitClause();
  Object TABLE();
};

class StartTransactionContextProxy : public ContextProxy {
public:
  StartTransactionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object transactionMode();
  Object transactionModeAt(size_t i);
  Object START();
  Object TRANSACTION();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class BeginWorkContextProxy : public ContextProxy {
public:
  BeginWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object BEGIN();
  Object WORK();
};

class CommitWorkContextProxy : public ContextProxy {
public:
  CommitWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMMIT();
  Object WORK();
  Object AND();
  Object CHAIN();
  Object RELEASE();
  Object NO();
  Object NOAt(size_t i);
};

class RollbackWorkContextProxy : public ContextProxy {
public:
  RollbackWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ROLLBACK();
  Object WORK();
  Object AND();
  Object CHAIN();
  Object RELEASE();
  Object NO();
  Object NOAt(size_t i);
};

class SavepointStatementContextProxy : public ContextProxy {
public:
  SavepointStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object SAVEPOINT();
};

class RollbackStatementContextProxy : public ContextProxy {
public:
  RollbackStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ROLLBACK();
  Object TO();
  Object WORK();
  Object SAVEPOINT();
};

class ReleaseStatementContextProxy : public ContextProxy {
public:
  ReleaseStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object RELEASE();
  Object SAVEPOINT();
};

class LockTablesContextProxy : public ContextProxy {
public:
  LockTablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lockTableElement();
  Object lockTableElementAt(size_t i);
  Object waitNowaitClause();
  Object LOCK();
  Object TABLE();
  Object TABLES();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class UnlockTablesContextProxy : public ContextProxy {
public:
  UnlockTablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object UNLOCK();
  Object TABLES();
};

class ChangeMasterContextProxy : public ContextProxy {
public:
  ChangeMasterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object masterOption();
  Object masterOptionAt(size_t i);
  Object channelOption();
  Object CHANGE();
  Object MASTER();
  Object TO();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ChangeReplicationFilterContextProxy : public ContextProxy {
public:
  ChangeReplicationFilterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object replicationFilter();
  Object replicationFilterAt(size_t i);
  Object CHANGE();
  Object REPLICATION();
  Object FILTER();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class PurgeBinaryLogsContextProxy : public ContextProxy {
public:
  PurgeBinaryLogsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PURGE();
  Object LOGS();
  Object BINARY();
  Object MASTER();
  Object TO();
  Object BEFORE();
  Object STRING_LITERAL();
};

class ResetMasterContextProxy : public ContextProxy {
public:
  ResetMasterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object RESET();
  Object MASTER();
};

class ResetSlaveContextProxy : public ContextProxy {
public:
  ResetSlaveContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object channelOption();
  Object RESET();
  Object SLAVE();
  Object ALL();
};

class StartSlaveContextProxy : public ContextProxy {
public:
  StartSlaveContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object threadType();
  Object threadTypeAt(size_t i);
  Object untilOption();
  Object connectionOption();
  Object connectionOptionAt(size_t i);
  Object channelOption();
  Object START();
  Object SLAVE();
  Object UNTIL();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class StopSlaveContextProxy : public ContextProxy {
public:
  StopSlaveContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object threadType();
  Object threadTypeAt(size_t i);
  Object STOP();
  Object SLAVE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class StartGroupReplicationContextProxy : public ContextProxy {
public:
  StartGroupReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object START();
  Object GROUP_REPLICATION();
};

class StopGroupReplicationContextProxy : public ContextProxy {
public:
  StopGroupReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STOP();
  Object GROUP_REPLICATION();
};

class XaStartTransactionContextProxy : public ContextProxy {
public:
  XaStartTransactionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object START();
  Object BEGIN();
  Object JOIN();
  Object RESUME();
};

class XaEndTransactionContextProxy : public ContextProxy {
public:
  XaEndTransactionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object END();
  Object SUSPEND();
  Object FOR();
  Object MIGRATE();
};

class XaPrepareStatementContextProxy : public ContextProxy {
public:
  XaPrepareStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object PREPARE();
};

class XaCommitWorkContextProxy : public ContextProxy {
public:
  XaCommitWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object COMMIT();
  Object ONE();
  Object PHASE();
};

class XaRollbackWorkContextProxy : public ContextProxy {
public:
  XaRollbackWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object ROLLBACK();
};

class XaRecoverWorkContextProxy : public ContextProxy {
public:
  XaRecoverWorkContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xid();
  Object XA();
  Object RECOVER();
  Object CONVERT();
};

class PrepareStatementContextProxy : public ContextProxy {
public:
  PrepareStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object PREPARE();
  Object FROM();
  Object STRING_LITERAL();
  Object LOCAL_ID();
};

class ExecuteStatementContextProxy : public ContextProxy {
public:
  ExecuteStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object userVariables();
  Object EXECUTE();
  Object USING();
};

class DeallocatePrepareContextProxy : public ContextProxy {
public:
  DeallocatePrepareContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object PREPARE();
  Object DEALLOCATE();
  Object DROP();
};

class CompoundStatementContextProxy : public ContextProxy {
public:
  CompoundStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object blockStatement();
  Object caseStatement();
  Object ifStatement();
  Object leaveStatement();
  Object loopStatement();
  Object repeatStatement();
  Object whileStatement();
  Object iterateStatement();
  Object returnStatement();
  Object cursorStatement();

};

class BlockStatementContextProxy : public ContextProxy {
public:
  BlockStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object declareVariable();
  Object declareVariableAt(size_t i);
  Object declareCondition();
  Object declareConditionAt(size_t i);
  Object declareCursor();
  Object declareCursorAt(size_t i);
  Object declareHandler();
  Object declareHandlerAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object BEGIN();
  Object END();
  Object COLON_SYMB();
  Object SEMI();
  Object SEMIAt(size_t i);
};

class CaseStatementContextProxy : public ContextProxy {
public:
  CaseStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object expression();
  Object caseAlternative();
  Object caseAlternativeAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object CASE();
  Object CASEAt(size_t i);
  Object END();
  Object ELSE();
};

class IfStatementContextProxy : public ContextProxy {
public:
  IfStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object elifAlternative();
  Object elifAlternativeAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object IF();
  Object IFAt(size_t i);
  Object THEN();
  Object END();
  Object ELSE();
};

class LeaveStatementContextProxy : public ContextProxy {
public:
  LeaveStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object LEAVE();
};

class LoopStatementContextProxy : public ContextProxy {
public:
  LoopStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object LOOP();
  Object LOOPAt(size_t i);
  Object END();
  Object COLON_SYMB();
};

class RepeatStatementContextProxy : public ContextProxy {
public:
  RepeatStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object uidAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object REPEAT();
  Object REPEATAt(size_t i);
  Object UNTIL();
  Object END();
  Object COLON_SYMB();
};

class WhileStatementContextProxy : public ContextProxy {
public:
  WhileStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object uidAt(size_t i);
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object WHILE();
  Object WHILEAt(size_t i);
  Object DO();
  Object END();
  Object COLON_SYMB();
};

class IterateStatementContextProxy : public ContextProxy {
public:
  IterateStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ITERATE();
};

class ReturnStatementContextProxy : public ContextProxy {
public:
  ReturnStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object RETURN();
};

class CursorStatementContextProxy : public ContextProxy {
public:
  CursorStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class AlterUserContextProxy : public ContextProxy {
public:
  AlterUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class CreateUserContextProxy : public ContextProxy {
public:
  CreateUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class DropUserContextProxy : public ContextProxy {
public:
  DropUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object ifExists();
  Object DROP();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class GrantStatementContextProxy : public ContextProxy {
public:
  GrantStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object privelegeClause();
  Object privelegeClauseAt(size_t i);
  Object privilegeLevel();
  Object userAuthOption();
  Object userAuthOptionAt(size_t i);
  Object userName();
  Object userNameAt(size_t i);
  Object roleOption();
  Object tlsOption();
  Object tlsOptionAt(size_t i);
  Object userResourceOption();
  Object userResourceOptionAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object GRANT();
  Object GRANTAt(size_t i);
  Object ON();
  Object TO();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object REQUIRE();
  Object WITH();
  Object WITHAt(size_t i);
  Object AS();
  Object ROLE();
  Object TABLE();
  Object FUNCTION();
  Object PROCEDURE();
  Object NONE();
  Object OPTION();
  Object OPTIONAt(size_t i);
  Object AND();
  Object ANDAt(size_t i);
  Object ADMIN();
};

class GrantProxyContextProxy : public ContextProxy {
public:
  GrantProxyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object GRANT();
  Object GRANTAt(size_t i);
  Object PROXY();
  Object ON();
  Object TO();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object WITH();
  Object OPTION();
};

class RenameUserContextProxy : public ContextProxy {
public:
  RenameUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object renameUserClause();
  Object renameUserClauseAt(size_t i);
  Object RENAME();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class RevokeStatementContextProxy : public ContextProxy {
public:
  RevokeStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class RevokeProxyContextProxy : public ContextProxy {
public:
  RevokeProxyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object REVOKE();
  Object PROXY();
  Object ON();
  Object FROM();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AnalyzeTableContextProxy : public ContextProxy {
public:
  AnalyzeTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object fullColumnName();
  Object fullColumnNameAt(size_t i);
  Object decimalLiteral();
  Object ANALYZE();
  Object TABLE();
  Object TABLES();
  Object UPDATE();
  Object HISTOGRAM();
  Object HISTOGRAMAt(size_t i);
  Object ON();
  Object ONAt(size_t i);
  Object DROP();
  Object NO_WRITE_TO_BINLOG();
  Object LOCAL();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object WITH();
  Object BUCKETS();
};

class CheckTableContextProxy : public ContextProxy {
public:
  CheckTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object checkTableOption();
  Object checkTableOptionAt(size_t i);
  Object CHECK();
  Object TABLE();
};

class ChecksumTableContextProxy : public ContextProxy {
public:
  ChecksumTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object CHECKSUM();
  Object TABLE();
  Object QUICK();
  Object EXTENDED();
};

class OptimizeTableContextProxy : public ContextProxy {
public:
  OptimizeTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object OPTIMIZE();
  Object TABLE();
  Object TABLES();
  Object NO_WRITE_TO_BINLOG();
  Object LOCAL();
};

class RepairTableContextProxy : public ContextProxy {
public:
  RepairTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object REPAIR();
  Object TABLE();
  Object QUICK();
  Object EXTENDED();
  Object USE_FRM();
  Object NO_WRITE_TO_BINLOG();
  Object LOCAL();
};

class CreateUdfunctionContextProxy : public ContextProxy {
public:
  CreateUdfunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ifNotExists();
  Object CREATE();
  Object FUNCTION();
  Object RETURNS();
  Object SONAME();
  Object STRING_LITERAL();
  Object STRING();
  Object INTEGER();
  Object REAL();
  Object DECIMAL();
  Object AGGREGATE();
};

class InstallPluginContextProxy : public ContextProxy {
public:
  InstallPluginContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object INSTALL();
  Object PLUGIN();
  Object SONAME();
  Object STRING_LITERAL();
};

class UninstallPluginContextProxy : public ContextProxy {
public:
  UninstallPluginContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object UNINSTALL();
  Object PLUGIN();
};

class SetStatementContextProxy : public ContextProxy {
public:
  SetStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ShowStatementContextProxy : public ContextProxy {
public:
  ShowStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class BinlogStatementContextProxy : public ContextProxy {
public:
  BinlogStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object BINLOG();
  Object STRING_LITERAL();
};

class CacheIndexStatementContextProxy : public ContextProxy {
public:
  CacheIndexStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableIndexes();
  Object tableIndexesAt(size_t i);
  Object uid();
  Object uidList();
  Object CACHE();
  Object INDEX();
  Object IN();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object PARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object ALL();
};

class FlushStatementContextProxy : public ContextProxy {
public:
  FlushStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object flushOption();
  Object flushOptionAt(size_t i);
  Object FLUSH();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object NO_WRITE_TO_BINLOG();
  Object LOCAL();
};

class KillStatementContextProxy : public ContextProxy {
public:
  KillStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object KILL();
  Object CONNECTION();
  Object QUERY();
};

class LoadIndexIntoCacheContextProxy : public ContextProxy {
public:
  LoadIndexIntoCacheContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object loadedTableIndexes();
  Object loadedTableIndexesAt(size_t i);
  Object LOAD();
  Object INDEX();
  Object INTO();
  Object CACHE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ResetStatementContextProxy : public ContextProxy {
public:
  ResetStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object RESET();
  Object QUERY();
  Object CACHE();
};

class ShutdownStatementContextProxy : public ContextProxy {
public:
  ShutdownStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SHUTDOWN();
};

class SimpleDescribeStatementContextProxy : public ContextProxy {
public:
  SimpleDescribeStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object EXPLAIN();
  Object DESCRIBE();
  Object DESC();
  Object STRING_LITERAL();
};

class FullDescribeStatementContextProxy : public ContextProxy {
public:
  FullDescribeStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object describeObjectClause();
  Object EXPLAIN();
  Object DESCRIBE();
  Object DESC();
  Object EQUAL_SYMBOL();
  Object EXTENDED();
  Object PARTITIONS();
  Object FORMAT();
  Object TRADITIONAL();
  Object JSON();
};

class HelpStatementContextProxy : public ContextProxy {
public:
  HelpStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object HELP();
  Object STRING_LITERAL();
};

class UseStatementContextProxy : public ContextProxy {
public:
  UseStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object USE();
};

class SignalStatementContextProxy : public ContextProxy {
public:
  SignalStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object signalConditionInformation();
  Object signalConditionInformationAt(size_t i);
  Object stringLiteral();
  Object SIGNAL();
  Object ID();
  Object REVERSE_QUOTE_ID();
  Object SET();
  Object SQLSTATE();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object VALUE();
};

class ResignalStatementContextProxy : public ContextProxy {
public:
  ResignalStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object signalConditionInformation();
  Object signalConditionInformationAt(size_t i);
  Object stringLiteral();
  Object RESIGNAL();
  Object ID();
  Object REVERSE_QUOTE_ID();
  Object SET();
  Object SQLSTATE();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object VALUE();
};

class DiagnosticsStatementContextProxy : public ContextProxy {
public:
  DiagnosticsStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object variableClause();
  Object variableClauseAt(size_t i);
  Object diagnosticsConditionInformationName();
  Object diagnosticsConditionInformationNameAt(size_t i);
  Object decimalLiteral();
  Object GET();
  Object DIAGNOSTICS();
  Object CURRENT();
  Object STACKED();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object CONDITION();
  Object NUMBER();
  Object NUMBERAt(size_t i);
  Object ROW_COUNT();
  Object ROW_COUNTAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class UidContextProxy : public ContextProxy {
public:
  UidContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object simpleId();
  Object CHARSET_REVERSE_QOUTE_STRING();
  Object STRING_LITERAL();
};

class IfNotExistsContextProxy : public ContextProxy {
public:
  IfNotExistsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object IF();
  Object NOT();
  Object EXISTS();
};

class CreateDatabaseOptionContextProxy : public ContextProxy {
public:
  CreateDatabaseOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charSet();
  Object charsetName();
  Object collationName();
  Object DEFAULT();
  Object DEFAULTAt(size_t i);
  Object EQUAL_SYMBOL();
  Object COLLATE();
  Object ENCRYPTION();
  Object STRING_LITERAL();
  Object READ();
  Object ONLY();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
};

class FullIdContextProxy : public ContextProxy {
public:
  FullIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object DOT_ID();
  Object DOT();
};

class ScheduleExpressionContextProxy : public ContextProxy {
public:
  ScheduleExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class RoutineBodyContextProxy : public ContextProxy {
public:
  RoutineBodyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object blockStatement();
  Object sqlStatement();

};

class OwnerStatementContextProxy : public ContextProxy {
public:
  OwnerStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object currentUserExpression();
  Object DEFINER();
  Object EQUAL_SYMBOL();
};

class EnableTypeContextProxy : public ContextProxy {
public:
  EnableTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ENABLE();
  Object DISABLE();
  Object ON();
  Object SLAVE();
};

class TableNameContextProxy : public ContextProxy {
public:
  TableNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();

};

class IndexColumnNamesContextProxy : public ContextProxy {
public:
  IndexColumnNamesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnName();
  Object indexColumnNameAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class IndexTypeContextProxy : public ContextProxy {
public:
  IndexTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object USING();
  Object BTREE();
  Object HASH();
};

class IndexOptionContextProxy : public ContextProxy {
public:
  IndexOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fileSizeLiteral();
  Object indexType();
  Object uid();
  Object KEY_BLOCK_SIZE();
  Object EQUAL_SYMBOL();
  Object WITH();
  Object PARSER();
  Object COMMENT();
  Object STRING_LITERAL();
  Object VISIBLE();
  Object INVISIBLE();
  Object ENGINE_ATTRIBUTE();
  Object SECONDARY_ENGINE_ATTRIBUTE();
};

class EngineNameContextProxy : public ContextProxy {
public:
  EngineNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object engineNameBase();
  Object ID();
  Object STRING_LITERAL();
};

class FileSizeLiteralContextProxy : public ContextProxy {
public:
  FileSizeLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object FILESIZE_LITERAL();
};

class ProcedureParameterContextProxy : public ContextProxy {
public:
  ProcedureParameterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object dataType();
  Object IN();
  Object OUT();
  Object INOUT();
};

class RoutineOptionContextProxy : public ContextProxy {
public:
  RoutineOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class DataTypeContextProxy : public ContextProxy {
public:
  DataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class FunctionParameterContextProxy : public ContextProxy {
public:
  FunctionParameterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object dataType();

};

class RoleNameContextProxy : public ContextProxy {
public:
  RoleNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object uid();

};

class ServerOptionContextProxy : public ContextProxy {
public:
  ServerOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object HOST();
  Object STRING_LITERAL();
  Object DATABASE();
  Object USER();
  Object PASSWORD();
  Object SOCKET();
  Object OWNER();
  Object PORT();
};

class CopyCreateTableContextProxy : public ContextProxy {
public:
  CopyCreateTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object tableNameAt(size_t i);
  Object ifNotExists();
  Object CREATE();
  Object TABLE();
  Object LIKE();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object TEMPORARY();
};

class ColumnCreateTableContextProxy : public ContextProxy {
public:
  ColumnCreateTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object createDefinitions();
  Object ifNotExists();
  Object tableOption();
  Object tableOptionAt(size_t i);
  Object partitionDefinitions();
  Object CREATE();
  Object TABLE();
  Object TEMPORARY();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CreateDefinitionsContextProxy : public ContextProxy {
public:
  CreateDefinitionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object createDefinition();
  Object createDefinitionAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class TableOptionContextProxy : public ContextProxy {
public:
  TableOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class PartitionDefinitionsContextProxy : public ContextProxy {
public:
  PartitionDefinitionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object partitionFunctionDefinition();
  Object subpartitionFunctionDefinition();
  Object partitionDefinition();
  Object partitionDefinitionAt(size_t i);
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object PARTITION();
  Object BY();
  Object BYAt(size_t i);
  Object PARTITIONS();
  Object SUBPARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object SUBPARTITIONS();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class QueryCreateTableContextProxy : public ContextProxy {
public:
  QueryCreateTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object selectStatement();
  Object ifNotExists();
  Object createDefinitions();
  Object tableOption();
  Object tableOptionAt(size_t i);
  Object partitionDefinitions();
  Object CREATE();
  Object TABLE();
  Object TEMPORARY();
  Object AS();
  Object IGNORE();
  Object REPLACE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class WithClauseContextProxy : public ContextProxy {
public:
  WithClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object commonTableExpressions();
  Object WITH();
  Object RECURSIVE();
};

class CommonTableExpressionsContextProxy : public ContextProxy {
public:
  CommonTableExpressionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object cteName();
  Object dmlStatement();
  Object cteColumnName();
  Object cteColumnNameAt(size_t i);
  Object commonTableExpressions();
  Object AS();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CteNameContextProxy : public ContextProxy {
public:
  CteNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();

};

class CteColumnNameContextProxy : public ContextProxy {
public:
  CteColumnNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();

};

class OrReplaceContextProxy : public ContextProxy {
public:
  OrReplaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object OR();
  Object REPLACE();
};

class UidListContextProxy : public ContextProxy {
public:
  UidListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CharSetContextProxy : public ContextProxy {
public:
  CharSetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CHARACTER();
  Object SET();
  Object CHARSET();
  Object CHAR();
};

class CharsetNameContextProxy : public ContextProxy {
public:
  CharsetNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetNameBase();
  Object BINARY();
  Object STRING_LITERAL();
  Object CHARSET_REVERSE_QOUTE_STRING();
};

class CollationNameContextProxy : public ContextProxy {
public:
  CollationNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object STRING_LITERAL();
};

class CurrentUserExpressionContextProxy : public ContextProxy {
public:
  CurrentUserExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CURRENT_USER();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class UserNameContextProxy : public ContextProxy {
public:
  UserNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object simpleUserName();
  Object hostName();
  Object currentUserExpression();

};

class PreciseScheduleContextProxy : public ContextProxy {
public:
  PreciseScheduleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object timestampValue();
  Object intervalExpr();
  Object intervalExprAt(size_t i);
  Object AT();
};

class TimestampValueContextProxy : public ContextProxy {
public:
  TimestampValueContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object decimalLiteral();
  Object expression();
  Object CURRENT_TIMESTAMP();
};

class IntervalExprContextProxy : public ContextProxy {
public:
  IntervalExprContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object intervalType();
  Object decimalLiteral();
  Object expression();
  Object PLUS();
  Object INTERVAL();
};

class IntervalScheduleContextProxy : public ContextProxy {
public:
  IntervalScheduleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object intervalType();
  Object decimalLiteral();
  Object expression();
  Object timestampValue();
  Object timestampValueAt(size_t i);
  Object intervalExpr();
  Object intervalExprAt(size_t i);
  Object EVERY();
  Object STARTS();
  Object ENDS();
};

class IntervalTypeContextProxy : public ContextProxy {
public:
  IntervalTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object intervalTypeBase();
  Object YEAR();
  Object YEAR_MONTH();
  Object DAY_HOUR();
  Object DAY_MINUTE();
  Object DAY_SECOND();
  Object HOUR_MINUTE();
  Object HOUR_SECOND();
  Object MINUTE_SECOND();
  Object SECOND_MICROSECOND();
  Object MINUTE_MICROSECOND();
  Object HOUR_MICROSECOND();
  Object DAY_MICROSECOND();
};

class DecimalLiteralContextProxy : public ContextProxy {
public:
  DecimalLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DECIMAL_LITERAL();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object TWO_DECIMAL();
  Object REAL_LITERAL();
};

class ExpressionContextProxy : public ContextProxy {
public:
  ExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class StringLiteralContextProxy : public ContextProxy {
public:
  StringLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object collationName();
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object START_NATIONAL_STRING_LITERAL();
  Object STRING_CHARSET_NAME();
  Object COLLATE();
};

class IntervalTypeBaseContextProxy : public ContextProxy {
public:
  IntervalTypeBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object QUARTER();
  Object MONTH();
  Object DAY();
  Object HOUR();
  Object MINUTE();
  Object WEEK();
  Object SECOND();
  Object MICROSECOND();
};

class RoutineBehaviorContextProxy : public ContextProxy {
public:
  RoutineBehaviorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DETERMINISTIC();
  Object NOT();
};

class RoutineLanguageContextProxy : public ContextProxy {
public:
  RoutineLanguageContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LANGUAGE();
  Object SQL();
};

class RoutineCommentContextProxy : public ContextProxy {
public:
  RoutineCommentContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMMENT();
  Object STRING_LITERAL();
};

class RoutineSecurityContextProxy : public ContextProxy {
public:
  RoutineSecurityContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SQL();
  Object SECURITY();
  Object DEFINER();
  Object INVOKER();
};

class RoutineDataContextProxy : public ContextProxy {
public:
  RoutineDataContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CONTAINS();
  Object SQL();
  Object NO();
  Object READS();
  Object DATA();
  Object MODIFIES();
};

class CreateDefinitionContextProxy : public ContextProxy {
public:
  CreateDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class FullColumnNameContextProxy : public ContextProxy {
public:
  FullColumnNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object dottedId();
  Object dottedIdAt(size_t i);

};

class ColumnDeclarationContextProxy : public ContextProxy {
public:
  ColumnDeclarationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object columnDefinition();

};

class ColumnDefinitionContextProxy : public ContextProxy {
public:
  ColumnDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object dataType();
  Object columnConstraint();
  Object columnConstraintAt(size_t i);
  Object NOT();
  Object ENFORCED();
};

class TableConstraintContextProxy : public ContextProxy {
public:
  TableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ConstraintDeclarationContextProxy : public ContextProxy {
public:
  ConstraintDeclarationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableConstraint();
  Object NOT();
  Object ENFORCED();
};

class IndexColumnDefinitionContextProxy : public ContextProxy {
public:
  IndexColumnDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class IndexDeclarationContextProxy : public ContextProxy {
public:
  IndexDeclarationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnDefinition();

};

class ColumnConstraintContextProxy : public ContextProxy {
public:
  ColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class StorageColumnConstraintContextProxy : public ContextProxy {
public:
  StorageColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STORAGE();
  Object DISK();
  Object MEMORY();
  Object DEFAULT();
};

class VisibilityColumnConstraintContextProxy : public ContextProxy {
public:
  VisibilityColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object VISIBLE();
};

class AutoIncrementColumnConstraintContextProxy : public ContextProxy {
public:
  AutoIncrementColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object currentTimestamp();
  Object AUTO_INCREMENT();
  Object ON();
  Object UPDATE();
};

class CurrentTimestampContextProxy : public ContextProxy {
public:
  CurrentTimestampContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object NOW();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object CURRENT_TIMESTAMP();
  Object LOCALTIME();
  Object LOCALTIMESTAMP();
};

class CommentColumnConstraintContextProxy : public ContextProxy {
public:
  CommentColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMMENT();
  Object STRING_LITERAL();
};

class UniqueKeyColumnConstraintContextProxy : public ContextProxy {
public:
  UniqueKeyColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object UNIQUE();
  Object KEY();
};

class SerialDefaultColumnConstraintContextProxy : public ContextProxy {
public:
  SerialDefaultColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SERIAL();
  Object DEFAULT();
  Object VALUE();
};

class GeneratedColumnConstraintContextProxy : public ContextProxy {
public:
  GeneratedColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object AS();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object GENERATED();
  Object ALWAYS();
  Object VIRTUAL();
  Object STORED();
};

class FormatColumnConstraintContextProxy : public ContextProxy {
public:
  FormatColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COLUMN_FORMAT();
  Object FIXED();
  Object DYNAMIC();
  Object DEFAULT();
};

class CollateColumnConstraintContextProxy : public ContextProxy {
public:
  CollateColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object collationName();
  Object COLLATE();
};

class PrimaryKeyColumnConstraintContextProxy : public ContextProxy {
public:
  PrimaryKeyColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object KEY();
  Object PRIMARY();
};

class CheckColumnConstraintContextProxy : public ContextProxy {
public:
  CheckColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object CHECK();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object CONSTRAINT();
};

class NullNotnullContextProxy : public ContextProxy {
public:
  NullNotnullContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object NULL_LITERAL();
  Object NULL_SPEC_LITERAL();
  Object NOT();
};

class NullColumnConstraintContextProxy : public ContextProxy {
public:
  NullColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object nullNotnull();

};

class DefaultColumnConstraintContextProxy : public ContextProxy {
public:
  DefaultColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object defaultValue();
  Object DEFAULT();
};

class DefaultValueContextProxy : public ContextProxy {
public:
  DefaultValueContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object convertedDataType();
  Object constant();
  Object unaryOperator();
  Object currentTimestamp();
  Object currentTimestampAt(size_t i);
  Object fullId();
  Object NULL_LITERAL();
  Object CAST();
  Object LR_BRACKET();
  Object AS();
  Object RR_BRACKET();
  Object ON();
  Object UPDATE();
};

class ReferenceDefinitionContextProxy : public ContextProxy {
public:
  ReferenceDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object indexColumnNames();
  Object referenceAction();
  Object REFERENCES();
  Object MATCH();
  Object FULL();
  Object PARTIAL();
  Object SIMPLE();
};

class ReferenceColumnConstraintContextProxy : public ContextProxy {
public:
  ReferenceColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object referenceDefinition();

};

class InvisibilityColumnConstraintContextProxy : public ContextProxy {
public:
  InvisibilityColumnConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object INVISIBLE();
};

class UniqueKeyTableConstraintContextProxy : public ContextProxy {
public:
  UniqueKeyTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object UNIQUE();
  Object CONSTRAINT();
  Object INDEX();
  Object KEY();
};

class CheckTableConstraintContextProxy : public ContextProxy {
public:
  CheckTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object CHECK();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object CONSTRAINT();
};

class PrimaryKeyTableConstraintContextProxy : public ContextProxy {
public:
  PrimaryKeyTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object PRIMARY();
  Object KEY();
  Object CONSTRAINT();
};

class ForeignKeyTableConstraintContextProxy : public ContextProxy {
public:
  ForeignKeyTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object referenceDefinition();
  Object uid();
  Object uidAt(size_t i);
  Object FOREIGN();
  Object KEY();
  Object CONSTRAINT();
};

class ReferenceActionContextProxy : public ContextProxy {
public:
  ReferenceActionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object referenceControlType();
  Object referenceControlTypeAt(size_t i);
  Object ON();
  Object ONAt(size_t i);
  Object DELETE();
  Object UPDATE();
};

class ReferenceControlTypeContextProxy : public ContextProxy {
public:
  ReferenceControlTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object RESTRICT();
  Object CASCADE();
  Object SET();
  Object NULL_LITERAL();
  Object NO();
  Object ACTION();
  Object DEFAULT();
};

class SpecialIndexDeclarationContextProxy : public ContextProxy {
public:
  SpecialIndexDeclarationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object uid();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object FULLTEXT();
  Object SPATIAL();
  Object INDEX();
  Object KEY();
};

class SimpleIndexDeclarationContextProxy : public ContextProxy {
public:
  SimpleIndexDeclarationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object uid();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object INDEX();
  Object KEY();
};

class TableOptionEngineContextProxy : public ContextProxy {
public:
  TableOptionEngineContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object engineName();
  Object ENGINE();
  Object EQUAL_SYMBOL();
};

class TableOptionMaxRowsContextProxy : public ContextProxy {
public:
  TableOptionMaxRowsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MAX_ROWS();
  Object EQUAL_SYMBOL();
};

class TableOptionCollateContextProxy : public ContextProxy {
public:
  TableOptionCollateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object collationName();
  Object COLLATE();
  Object DEFAULT();
  Object EQUAL_SYMBOL();
};

class TableOptionPersistentContextProxy : public ContextProxy {
public:
  TableOptionPersistentContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STATS_PERSISTENT();
  Object DEFAULT();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionTablespaceContextProxy : public ContextProxy {
public:
  TableOptionTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object tablespaceStorage();
  Object TABLESPACE();
};

class TablespaceStorageContextProxy : public ContextProxy {
public:
  TablespaceStorageContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STORAGE();
  Object DISK();
  Object MEMORY();
  Object DEFAULT();
};

class TableOptionAutoextendSizeContextProxy : public ContextProxy {
public:
  TableOptionAutoextendSizeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object AUTOEXTEND_SIZE();
  Object EQUAL_SYMBOL();
};

class TableOptionPageCompressedContextProxy : public ContextProxy {
public:
  TableOptionPageCompressedContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PAGE_COMPRESSED();
  Object STRING_LITERAL();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionStartTransactionContextProxy : public ContextProxy {
public:
  TableOptionStartTransactionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object START();
  Object TRANSACTION();
};

class TableOptionPackKeysContextProxy : public ContextProxy {
public:
  TableOptionPackKeysContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PACK_KEYS();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object DEFAULT();
  Object EQUAL_SYMBOL();
};

class TableOptionPasswordContextProxy : public ContextProxy {
public:
  TableOptionPasswordContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PASSWORD();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionUnionContextProxy : public ContextProxy {
public:
  TableOptionUnionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object UNION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object EQUAL_SYMBOL();
};

class TablesContextProxy : public ContextProxy {
public:
  TablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object tableNameAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class TableOptionSamplePageContextProxy : public ContextProxy {
public:
  TableOptionSamplePageContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object STATS_SAMPLE_PAGES();
  Object DEFAULT();
  Object EQUAL_SYMBOL();
};

class TableOptionCharsetContextProxy : public ContextProxy {
public:
  TableOptionCharsetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charSet();
  Object charsetName();
  Object DEFAULT();
  Object DEFAULTAt(size_t i);
  Object EQUAL_SYMBOL();
};

class TableOptionIndexDirectoryContextProxy : public ContextProxy {
public:
  TableOptionIndexDirectoryContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object INDEX();
  Object DIRECTORY();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionTableTypeContextProxy : public ContextProxy {
public:
  TableOptionTableTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableType();
  Object TABLE_TYPE();
  Object EQUAL_SYMBOL();
};

class TableTypeContextProxy : public ContextProxy {
public:
  TableTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MYSQL();
  Object ODBC();
};

class TableOptionKeyBlockSizeContextProxy : public ContextProxy {
public:
  TableOptionKeyBlockSizeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fileSizeLiteral();
  Object KEY_BLOCK_SIZE();
  Object EQUAL_SYMBOL();
};

class TableOptionEncryptionContextProxy : public ContextProxy {
public:
  TableOptionEncryptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ENCRYPTION();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionDataDirectoryContextProxy : public ContextProxy {
public:
  TableOptionDataDirectoryContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DIRECTORY();
  Object STRING_LITERAL();
  Object DATA();
  Object INDEX();
  Object EQUAL_SYMBOL();
};

class TableOptionRecalculationContextProxy : public ContextProxy {
public:
  TableOptionRecalculationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STATS_AUTO_RECALC();
  Object DEFAULT();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionAutoIncrementContextProxy : public ContextProxy {
public:
  TableOptionAutoIncrementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object AUTO_INCREMENT();
  Object EQUAL_SYMBOL();
};

class TableOptionEncryptionKeyIdContextProxy : public ContextProxy {
public:
  TableOptionEncryptionKeyIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object ENCRYPTION_KEY_ID();
  Object EQUAL_SYMBOL();
};

class TableOptionChecksumContextProxy : public ContextProxy {
public:
  TableOptionChecksumContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CHECKSUM();
  Object PAGE_CHECKSUM();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionDelayContextProxy : public ContextProxy {
public:
  TableOptionDelayContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DELAY_KEY_WRITE();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionConnectionContextProxy : public ContextProxy {
public:
  TableOptionConnectionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CONNECTION();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionTransactionalContextProxy : public ContextProxy {
public:
  TableOptionTransactionalContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object TRANSACTIONAL();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
  Object EQUAL_SYMBOL();
};

class TableOptionPageCompressionLevelContextProxy : public ContextProxy {
public:
  TableOptionPageCompressionLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object PAGE_COMPRESSION_LEVEL();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionSecondaryEngineAttributeContextProxy : public ContextProxy {
public:
  TableOptionSecondaryEngineAttributeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SECONDARY_ENGINE_ATTRIBUTE();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionCommentContextProxy : public ContextProxy {
public:
  TableOptionCommentContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMMENT();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionAverageContextProxy : public ContextProxy {
public:
  TableOptionAverageContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object AVG_ROW_LENGTH();
  Object EQUAL_SYMBOL();
};

class TableOptionRowFormatContextProxy : public ContextProxy {
public:
  TableOptionRowFormatContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ROW_FORMAT();
  Object DEFAULT();
  Object DYNAMIC();
  Object FIXED();
  Object COMPRESSED();
  Object REDUNDANT();
  Object COMPACT();
  Object ID();
  Object EQUAL_SYMBOL();
};

class TableOptionCompressionContextProxy : public ContextProxy {
public:
  TableOptionCompressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMPRESSION();
  Object STRING_LITERAL();
  Object ID();
  Object EQUAL_SYMBOL();
};

class TableOptionInsertMethodContextProxy : public ContextProxy {
public:
  TableOptionInsertMethodContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object INSERT_METHOD();
  Object NO();
  Object FIRST();
  Object LAST();
  Object EQUAL_SYMBOL();
};

class TableOptionEngineAttributeContextProxy : public ContextProxy {
public:
  TableOptionEngineAttributeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ENGINE_ATTRIBUTE();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class TableOptionMinRowsContextProxy : public ContextProxy {
public:
  TableOptionMinRowsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MIN_ROWS();
  Object EQUAL_SYMBOL();
};

class PartitionFunctionDefinitionContextProxy : public ContextProxy {
public:
  PartitionFunctionDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SubpartitionFunctionDefinitionContextProxy : public ContextProxy {
public:
  SubpartitionFunctionDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class PartitionDefinitionContextProxy : public ContextProxy {
public:
  PartitionDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class PartitionFunctionKeyContextProxy : public ContextProxy {
public:
  PartitionFunctionKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object KEY();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LINEAR();
  Object ALGORITHM();
  Object EQUAL_SYMBOL();
  Object ONE_DECIMAL();
  Object TWO_DECIMAL();
};

class PartitionFunctionHashContextProxy : public ContextProxy {
public:
  PartitionFunctionHashContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object HASH();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LINEAR();
};

class PartitionFunctionListContextProxy : public ContextProxy {
public:
  PartitionFunctionListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uidList();
  Object LIST();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COLUMNS();
};

class PartitionFunctionRangeContextProxy : public ContextProxy {
public:
  PartitionFunctionRangeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uidList();
  Object RANGE();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COLUMNS();
};

class SubPartitionFunctionHashContextProxy : public ContextProxy {
public:
  SubPartitionFunctionHashContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object HASH();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LINEAR();
};

class SubPartitionFunctionKeyContextProxy : public ContextProxy {
public:
  SubPartitionFunctionKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object KEY();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LINEAR();
  Object ALGORITHM();
  Object EQUAL_SYMBOL();
  Object ONE_DECIMAL();
  Object TWO_DECIMAL();
};

class PartitionComparisonContextProxy : public ContextProxy {
public:
  PartitionComparisonContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object partitionDefinerAtom();
  Object partitionDefinerAtomAt(size_t i);
  Object partitionOption();
  Object partitionOptionAt(size_t i);
  Object subpartitionDefinition();
  Object subpartitionDefinitionAt(size_t i);
  Object PARTITION();
  Object VALUES();
  Object LESS();
  Object THAN();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class PartitionDefinerAtomContextProxy : public ContextProxy {
public:
  PartitionDefinerAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();
  Object expression();
  Object MAXVALUE();
};

class PartitionOptionContextProxy : public ContextProxy {
public:
  PartitionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SubpartitionDefinitionContextProxy : public ContextProxy {
public:
  SubpartitionDefinitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object partitionOption();
  Object partitionOptionAt(size_t i);
  Object SUBPARTITION();
};

class PartitionListAtomContextProxy : public ContextProxy {
public:
  PartitionListAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object partitionDefinerAtom();
  Object partitionDefinerAtomAt(size_t i);
  Object partitionOption();
  Object partitionOptionAt(size_t i);
  Object subpartitionDefinition();
  Object subpartitionDefinitionAt(size_t i);
  Object PARTITION();
  Object VALUES();
  Object IN();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class PartitionListVectorContextProxy : public ContextProxy {
public:
  PartitionListVectorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object partitionDefinerVector();
  Object partitionDefinerVectorAt(size_t i);
  Object partitionOption();
  Object partitionOptionAt(size_t i);
  Object subpartitionDefinition();
  Object subpartitionDefinitionAt(size_t i);
  Object PARTITION();
  Object VALUES();
  Object IN();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class PartitionDefinerVectorContextProxy : public ContextProxy {
public:
  PartitionDefinerVectorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object partitionDefinerAtom();
  Object partitionDefinerAtomAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class PartitionSimpleContextProxy : public ContextProxy {
public:
  PartitionSimpleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object partitionOption();
  Object partitionOptionAt(size_t i);
  Object subpartitionDefinition();
  Object subpartitionDefinitionAt(size_t i);
  Object PARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ConstantContextProxy : public ContextProxy {
public:
  ConstantContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object decimalLiteral();
  Object hexadecimalLiteral();
  Object booleanLiteral();
  Object MINUS();
  Object REAL_LITERAL();
  Object BIT_STRING();
  Object NULL_LITERAL();
  Object NULL_SPEC_LITERAL();
  Object NOT();
};

class PartitionOptionCommentContextProxy : public ContextProxy {
public:
  PartitionOptionCommentContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object COMMENT();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class PartitionOptionNodeGroupContextProxy : public ContextProxy {
public:
  PartitionOptionNodeGroupContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object NODEGROUP();
  Object EQUAL_SYMBOL();
};

class PartitionOptionIndexDirectoryContextProxy : public ContextProxy {
public:
  PartitionOptionIndexDirectoryContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object INDEX();
  Object DIRECTORY();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class PartitionOptionMaxRowsContextProxy : public ContextProxy {
public:
  PartitionOptionMaxRowsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MAX_ROWS();
  Object EQUAL_SYMBOL();
};

class PartitionOptionTablespaceContextProxy : public ContextProxy {
public:
  PartitionOptionTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object TABLESPACE();
  Object EQUAL_SYMBOL();
};

class PartitionOptionEngineContextProxy : public ContextProxy {
public:
  PartitionOptionEngineContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object engineName();
  Object ENGINE();
  Object DEFAULT();
  Object STORAGE();
  Object EQUAL_SYMBOL();
};

class PartitionOptionMinRowsContextProxy : public ContextProxy {
public:
  PartitionOptionMinRowsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MIN_ROWS();
  Object EQUAL_SYMBOL();
};

class PartitionOptionDataDirectoryContextProxy : public ContextProxy {
public:
  PartitionOptionDataDirectoryContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DATA();
  Object DIRECTORY();
  Object STRING_LITERAL();
  Object EQUAL_SYMBOL();
};

class AlterUpgradeNameContextProxy : public ContextProxy {
public:
  AlterUpgradeNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ALTER();
  Object UPGRADE();
  Object DATA();
  Object DIRECTORY();
  Object NAME();
  Object DATABASE();
  Object SCHEMA();
};

class AlterSimpleDatabaseContextProxy : public ContextProxy {
public:
  AlterSimpleDatabaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object createDatabaseOption();
  Object createDatabaseOptionAt(size_t i);
  Object ALTER();
  Object DATABASE();
  Object SCHEMA();
};

class WaitNowaitClauseContextProxy : public ContextProxy {
public:
  WaitNowaitClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object WAIT();
  Object NOWAIT();
};

class AlterSpecificationContextProxy : public ContextProxy {
public:
  AlterSpecificationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class AlterByAlterColumnDefaultContextProxy : public ContextProxy {
public:
  AlterByAlterColumnDefaultContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object stringLiteral();
  Object expression();
  Object ALTER();
  Object SET();
  Object DEFAULT();
  Object DROP();
  Object COLUMN();
  Object VISIBLE();
  Object INVISIBLE();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class AlterByDisableKeysContextProxy : public ContextProxy {
public:
  AlterByDisableKeysContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DISABLE();
  Object KEYS();
};

class AlterByDefaultCharsetContextProxy : public ContextProxy {
public:
  AlterByDefaultCharsetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetName();
  Object collationName();
  Object CHARACTER();
  Object SET();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object DEFAULT();
  Object COLLATE();
};

class AlterByRenameColumnContextProxy : public ContextProxy {
public:
  AlterByRenameColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object RENAME();
  Object COLUMN();
  Object TO();
};

class AlterByConvertCharsetContextProxy : public ContextProxy {
public:
  AlterByConvertCharsetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetName();
  Object collationName();
  Object CONVERT();
  Object TO();
  Object CHARSET();
  Object CHARACTER();
  Object SET();
  Object COLLATE();
};

class AlterByAddForeignKeyContextProxy : public ContextProxy {
public:
  AlterByAddForeignKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object referenceDefinition();
  Object uid();
  Object uidAt(size_t i);
  Object ADD();
  Object FOREIGN();
  Object KEY();
  Object CONSTRAINT();
};

class AlterByRenameIndexContextProxy : public ContextProxy {
public:
  AlterByRenameIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object RENAME();
  Object TO();
  Object INDEX();
  Object KEY();
};

class AlterByRenameContextProxy : public ContextProxy {
public:
  AlterByRenameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object fullId();
  Object RENAME();
  Object TO();
  Object AS();
};

class AlterByImportTablespaceContextProxy : public ContextProxy {
public:
  AlterByImportTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object IMPORT();
  Object TABLESPACE();
};

class AlterByAddDefinitionsContextProxy : public ContextProxy {
public:
  AlterByAddDefinitionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object createDefinition();
  Object createDefinitionAt(size_t i);
  Object ADD();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COLUMN();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterByAlterCheckTableConstraintContextProxy : public ContextProxy {
public:
  AlterByAlterCheckTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object stringLiteral();
  Object expression();
  Object ALTER();
  Object CHECK();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object CONSTRAINT();
  Object NOT();
  Object ENFORCED();
};

class AlterByDropConstraintCheckContextProxy : public ContextProxy {
public:
  AlterByDropConstraintCheckContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DROP();
  Object CONSTRAINT();
  Object CHECK();
};

class AlterByAddColumnsContextProxy : public ContextProxy {
public:
  AlterByAddColumnsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object columnDefinition();
  Object columnDefinitionAt(size_t i);
  Object ADD();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COLUMN();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterByAlterIndexVisibilityContextProxy : public ContextProxy {
public:
  AlterByAlterIndexVisibilityContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ALTER();
  Object INDEX();
  Object VISIBLE();
  Object INVISIBLE();
};

class AlterByDropForeignKeyContextProxy : public ContextProxy {
public:
  AlterByDropForeignKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DROP();
  Object FOREIGN();
  Object KEY();
};

class AlterByAddCheckTableConstraintContextProxy : public ContextProxy {
public:
  AlterByAddCheckTableConstraintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object stringLiteral();
  Object expression();
  Object ADD();
  Object CHECK();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object CONSTRAINT();
  Object NOT();
  Object ENFORCED();
};

class AlterPartitionSpecificationContextProxy : public ContextProxy {
public:
  AlterPartitionSpecificationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class AlterPartitionContextProxy : public ContextProxy {
public:
  AlterPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object alterPartitionSpecification();

};

class AlterByAddIndexContextProxy : public ContextProxy {
public:
  AlterByAddIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object uid();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object ADD();
  Object INDEX();
  Object KEY();
};

class AlterByDropColumnContextProxy : public ContextProxy {
public:
  AlterByDropColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DROP();
  Object COLUMN();
  Object RESTRICT();
};

class AlterByChangeDefaultContextProxy : public ContextProxy {
public:
  AlterByChangeDefaultContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object defaultValue();
  Object ALTER();
  Object SET();
  Object DEFAULT();
  Object DROP();
  Object COLUMN();
};

class AlterByForceContextProxy : public ContextProxy {
public:
  AlterByForceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object FORCE();
};

class AlterByAddSpecialIndexContextProxy : public ContextProxy {
public:
  AlterByAddSpecialIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object uid();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object ADD();
  Object FULLTEXT();
  Object SPATIAL();
  Object INDEX();
  Object KEY();
};

class AlterByModifyColumnContextProxy : public ContextProxy {
public:
  AlterByModifyColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object columnDefinition();
  Object MODIFY();
  Object COLUMN();
  Object FIRST();
  Object AFTER();
};

class AlterByTableOptionContextProxy : public ContextProxy {
public:
  AlterByTableOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableOption();
  Object tableOptionAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterByDropPrimaryKeyContextProxy : public ContextProxy {
public:
  AlterByDropPrimaryKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DROP();
  Object PRIMARY();
  Object KEY();
};

class AlterByLockContextProxy : public ContextProxy {
public:
  AlterByLockContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LOCK();
  Object DEFAULT();
  Object NONE();
  Object SHARED();
  Object EXCLUSIVE();
  Object EQUAL_SYMBOL();
};

class AlterByDiscardTablespaceContextProxy : public ContextProxy {
public:
  AlterByDiscardTablespaceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DISCARD();
  Object TABLESPACE();
};

class AlterByValidateContextProxy : public ContextProxy {
public:
  AlterByValidateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object VALIDATION();
  Object WITHOUT();
  Object WITH();
};

class AlterByAddPrimaryKeyContextProxy : public ContextProxy {
public:
  AlterByAddPrimaryKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object ADD();
  Object PRIMARY();
  Object KEY();
  Object CONSTRAINT();
};

class AlterByEnableKeysContextProxy : public ContextProxy {
public:
  AlterByEnableKeysContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ENABLE();
  Object KEYS();
};

class AlterBySetAlgorithmContextProxy : public ContextProxy {
public:
  AlterBySetAlgorithmContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ALGORITHM();
  Object DEFAULT();
  Object INSTANT();
  Object INPLACE();
  Object COPY();
  Object EQUAL_SYMBOL();
};

class AlterByChangeColumnContextProxy : public ContextProxy {
public:
  AlterByChangeColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object columnDefinition();
  Object uid();
  Object uidAt(size_t i);
  Object CHANGE();
  Object COLUMN();
  Object FIRST();
  Object AFTER();
};

class AlterByAddUniqueKeyContextProxy : public ContextProxy {
public:
  AlterByAddUniqueKeyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object indexColumnNames();
  Object indexType();
  Object indexOption();
  Object indexOptionAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object ADD();
  Object UNIQUE();
  Object CONSTRAINT();
  Object INDEX();
  Object KEY();
};

class AlterByDropIndexContextProxy : public ContextProxy {
public:
  AlterByDropIndexContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DROP();
  Object INDEX();
  Object KEY();
};

class AlterByAddColumnContextProxy : public ContextProxy {
public:
  AlterByAddColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object columnDefinition();
  Object ADD();
  Object COLUMN();
  Object FIRST();
  Object AFTER();
};

class AlterByOrderContextProxy : public ContextProxy {
public:
  AlterByOrderContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object ORDER();
  Object BY();
};

class AlterByImportPartitionContextProxy : public ContextProxy {
public:
  AlterByImportPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object IMPORT();
  Object PARTITION();
  Object TABLESPACE();
  Object ALL();
};

class AlterByDropPartitionContextProxy : public ContextProxy {
public:
  AlterByDropPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object DROP();
  Object PARTITION();
};

class AlterByDiscardPartitionContextProxy : public ContextProxy {
public:
  AlterByDiscardPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object DISCARD();
  Object PARTITION();
  Object TABLESPACE();
  Object ALL();
};

class AlterByAddPartitionContextProxy : public ContextProxy {
public:
  AlterByAddPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object partitionDefinition();
  Object partitionDefinitionAt(size_t i);
  Object ADD();
  Object PARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterByRemovePartitioningContextProxy : public ContextProxy {
public:
  AlterByRemovePartitioningContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object REMOVE();
  Object PARTITIONING();
};

class AlterByOptimizePartitionContextProxy : public ContextProxy {
public:
  AlterByOptimizePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object OPTIMIZE();
  Object PARTITION();
  Object ALL();
};

class AlterByCheckPartitionContextProxy : public ContextProxy {
public:
  AlterByCheckPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object CHECK();
  Object PARTITION();
  Object ALL();
};

class AlterByCoalescePartitionContextProxy : public ContextProxy {
public:
  AlterByCoalescePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object COALESCE();
  Object PARTITION();
};

class AlterByReorganizePartitionContextProxy : public ContextProxy {
public:
  AlterByReorganizePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object partitionDefinition();
  Object partitionDefinitionAt(size_t i);
  Object REORGANIZE();
  Object PARTITION();
  Object INTO();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AlterByAnalyzePartitionContextProxy : public ContextProxy {
public:
  AlterByAnalyzePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object ANALYZE();
  Object PARTITION();
  Object ALL();
};

class AlterByRebuildPartitionContextProxy : public ContextProxy {
public:
  AlterByRebuildPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object REBUILD();
  Object PARTITION();
  Object ALL();
};

class AlterByUpgradePartitioningContextProxy : public ContextProxy {
public:
  AlterByUpgradePartitioningContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object UPGRADE();
  Object PARTITIONING();
};

class AlterByTruncatePartitionContextProxy : public ContextProxy {
public:
  AlterByTruncatePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object TRUNCATE();
  Object PARTITION();
  Object ALL();
};

class AlterByRepairPartitionContextProxy : public ContextProxy {
public:
  AlterByRepairPartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object REPAIR();
  Object PARTITION();
  Object ALL();
};

class AlterByExchangePartitionContextProxy : public ContextProxy {
public:
  AlterByExchangePartitionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object tableName();
  Object EXCHANGE();
  Object PARTITION();
  Object WITH();
  Object WITHAt(size_t i);
  Object TABLE();
  Object VALIDATION();
  Object WITHOUT();
};

class IfExistsContextProxy : public ContextProxy {
public:
  IfExistsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object IF();
  Object EXISTS();
};

class RoleOptionContextProxy : public ContextProxy {
public:
  RoleOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object DEFAULT();
  Object NONE();
  Object ALL();
  Object EXCEPT();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class RenameTableClauseContextProxy : public ContextProxy {
public:
  RenameTableClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object tableNameAt(size_t i);
  Object TO();
};

class ConstantsContextProxy : public ContextProxy {
public:
  ConstantsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();
  Object constantAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ExpressionsContextProxy : public ContextProxy {
public:
  ExpressionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class SingleDeleteStatementContextProxy : public ContextProxy {
public:
  SingleDeleteStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object uidList();
  Object expression();
  Object orderByClause();
  Object limitClauseAtom();
  Object DELETE();
  Object FROM();
  Object QUICK();
  Object IGNORE();
  Object PARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object WHERE();
  Object LIMIT();
  Object LOW_PRIORITY();
  Object AS();
};

class MultipleDeleteStatementContextProxy : public ContextProxy {
public:
  MultipleDeleteStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object tableNameAt(size_t i);
  Object tableSources();
  Object expression();
  Object DELETE();
  Object FROM();
  Object USING();
  Object QUICK();
  Object IGNORE();
  Object WHERE();
  Object LOW_PRIORITY();
  Object DOT();
  Object DOTAt(size_t i);
  Object STAR();
  Object STARAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class HandlerOpenStatementContextProxy : public ContextProxy {
public:
  HandlerOpenStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object HANDLER();
  Object OPEN();
  Object AS();
};

class HandlerReadIndexStatementContextProxy : public ContextProxy {
public:
  HandlerReadIndexStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object comparisonOperator();
  Object constants();
  Object expression();
  Object limitClauseAtom();
  Object HANDLER();
  Object READ();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object WHERE();
  Object LIMIT();
  Object FIRST();
  Object NEXT();
  Object PREV();
  Object LAST();
};

class HandlerReadStatementContextProxy : public ContextProxy {
public:
  HandlerReadStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object expression();
  Object limitClauseAtom();
  Object HANDLER();
  Object READ();
  Object FIRST();
  Object NEXT();
  Object WHERE();
  Object LIMIT();
};

class HandlerCloseStatementContextProxy : public ContextProxy {
public:
  HandlerCloseStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object HANDLER();
  Object CLOSE();
};

class InsertStatementValueContextProxy : public ContextProxy {
public:
  InsertStatementValueContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectStatement();
  Object expressionsWithDefaults();
  Object expressionsWithDefaultsAt(size_t i);
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object VALUES();
  Object VALUE();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class UpdatedElementContextProxy : public ContextProxy {
public:
  UpdatedElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object expression();
  Object EQUAL_SYMBOL();
  Object DEFAULT();
};

class FullColumnNameListContextProxy : public ContextProxy {
public:
  FullColumnNameListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object fullColumnNameAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AssignmentFieldContextProxy : public ContextProxy {
public:
  AssignmentFieldContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object LOCAL_ID();
};

class SelectFieldsIntoContextProxy : public ContextProxy {
public:
  SelectFieldsIntoContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object TERMINATED();
  Object BY();
  Object STRING_LITERAL();
  Object ENCLOSED();
  Object OPTIONALLY();
  Object ESCAPED();
};

class SelectLinesIntoContextProxy : public ContextProxy {
public:
  SelectLinesIntoContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STARTING();
  Object BY();
  Object STRING_LITERAL();
  Object TERMINATED();
};

class QuerySpecificationNointoContextProxy : public ContextProxy {
public:
  QuerySpecificationNointoContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectElements();
  Object fromClause();
  Object selectSpec();
  Object selectSpecAt(size_t i);
  Object groupByClause();
  Object havingClause();
  Object windowClause();
  Object orderByClause();
  Object limitClause();
  Object unionStatement();
  Object SELECT();
};

class UnionSelectContextProxy : public ContextProxy {
public:
  UnionSelectContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecificationNointo();
  Object queryExpressionNointo();
  Object unionStatement();
  Object unionStatementAt(size_t i);
  Object orderByClause();
  Object limitClause();
  Object lockClause();
  Object querySpecification();
  Object queryExpression();
  Object UNION();
  Object ALL();
  Object DISTINCT();
};

class QueryExpressionNointoContextProxy : public ContextProxy {
public:
  QueryExpressionNointoContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecificationNointo();
  Object queryExpressionNointo();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class UnionStatementContextProxy : public ContextProxy {
public:
  UnionStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecificationNointo();
  Object queryExpressionNointo();
  Object UNION();
  Object ALL();
  Object DISTINCT();
};

class OrderByClauseContextProxy : public ContextProxy {
public:
  OrderByClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object orderByExpression();
  Object orderByExpressionAt(size_t i);
  Object ORDER();
  Object BY();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class LimitClauseContextProxy : public ContextProxy {
public:
  LimitClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object limitClauseAtom();
  Object limitClauseAtomAt(size_t i);
  Object LIMIT();
  Object OFFSET();
  Object COMMA();
};

class LockClauseContextProxy : public ContextProxy {
public:
  LockClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object FOR();
  Object UPDATE();
  Object LOCK();
  Object IN();
  Object SHARE();
  Object MODE();
};

class QuerySpecificationContextProxy : public ContextProxy {
public:
  QuerySpecificationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectElements();
  Object fromClause();
  Object selectSpec();
  Object selectSpecAt(size_t i);
  Object selectIntoExpression();
  Object groupByClause();
  Object havingClause();
  Object windowClause();
  Object orderByClause();
  Object limitClause();
  Object SELECT();
};

class QueryExpressionContextProxy : public ContextProxy {
public:
  QueryExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecification();
  Object queryExpression();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class UnionParenthesisSelectContextProxy : public ContextProxy {
public:
  UnionParenthesisSelectContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object queryExpressionNointo();
  Object unionParenthesis();
  Object unionParenthesisAt(size_t i);
  Object queryExpression();
  Object orderByClause();
  Object limitClause();
  Object lockClause();
  Object UNION();
  Object ALL();
  Object DISTINCT();
};

class UnionParenthesisContextProxy : public ContextProxy {
public:
  UnionParenthesisContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object queryExpressionNointo();
  Object UNION();
  Object ALL();
  Object DISTINCT();
};

class SimpleSelectContextProxy : public ContextProxy {
public:
  SimpleSelectContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecification();
  Object lockClause();

};

class ParenthesisSelectContextProxy : public ContextProxy {
public:
  ParenthesisSelectContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object queryExpression();
  Object lockClause();

};

class WithLateralStatementContextProxy : public ContextProxy {
public:
  WithLateralStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecificationNointo();
  Object lateralStatement();
  Object lateralStatementAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class LateralStatementContextProxy : public ContextProxy {
public:
  LateralStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object querySpecificationNointo();
  Object queryExpressionNointo();
  Object uid();
  Object LATERAL();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object AS();
};

class SingleUpdateStatementContextProxy : public ContextProxy {
public:
  SingleUpdateStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object uid();
  Object expression();
  Object orderByClause();
  Object limitClause();
  Object UPDATE();
  Object SET();
  Object IGNORE();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object WHERE();
  Object LOW_PRIORITY();
  Object AS();
};

class MultipleUpdateStatementContextProxy : public ContextProxy {
public:
  MultipleUpdateStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSources();
  Object updatedElement();
  Object updatedElementAt(size_t i);
  Object expression();
  Object UPDATE();
  Object SET();
  Object IGNORE();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object WHERE();
  Object LOW_PRIORITY();
};

class ExpressionsWithDefaultsContextProxy : public ContextProxy {
public:
  ExpressionsWithDefaultsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionOrDefault();
  Object expressionOrDefaultAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class LimitClauseAtomContextProxy : public ContextProxy {
public:
  LimitClauseAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object mysqlVariable();
  Object simpleId();

};

class TableSourcesContextProxy : public ContextProxy {
public:
  TableSourcesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSource();
  Object tableSourceAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ComparisonOperatorContextProxy : public ContextProxy {
public:
  ComparisonOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object EQUAL_SYMBOL();
  Object GREATER_SYMBOL();
  Object LESS_SYMBOL();
  Object EXCLAMATION_SYMBOL();
};

class OrderByExpressionContextProxy : public ContextProxy {
public:
  OrderByExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object ASC();
  Object DESC();
};

class TableSourceContextProxy : public ContextProxy {
public:
  TableSourceContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class JsonTableContextProxy : public ContextProxy {
public:
  JsonTableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object jsonColumnList();
  Object uid();
  Object JSON_TABLE();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object COMMA();
  Object COLUMNS();
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object AS();
};

class TableJsonContextProxy : public ContextProxy {
public:
  TableJsonContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object jsonTable();

};

class TableSourceNestedContextProxy : public ContextProxy {
public:
  TableSourceNestedContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object joinPart();
  Object joinPartAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class TableSourceItemContextProxy : public ContextProxy {
public:
  TableSourceItemContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class JoinPartContextProxy : public ContextProxy {
public:
  JoinPartContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class TableSourceBaseContextProxy : public ContextProxy {
public:
  TableSourceBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object joinPart();
  Object joinPartAt(size_t i);

};

class SubqueryTableItemContextProxy : public ContextProxy {
public:
  SubqueryTableItemContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object selectStatement();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object AS();
};

class AtomTableItemContextProxy : public ContextProxy {
public:
  AtomTableItemContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uidList();
  Object indexHint();
  Object indexHintAt(size_t i);
  Object uid();
  Object PARTITION();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object AS();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class IndexHintContextProxy : public ContextProxy {
public:
  IndexHintContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object indexHintType();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object USE();
  Object IGNORE();
  Object FORCE();
  Object INDEX();
  Object KEY();
  Object FOR();
};

class TableSourcesItemContextProxy : public ContextProxy {
public:
  TableSourcesItemContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSources();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class IndexHintTypeContextProxy : public ContextProxy {
public:
  IndexHintTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object JOIN();
  Object ORDER();
  Object BY();
  Object GROUP();
};

class InnerJoinContextProxy : public ContextProxy {
public:
  InnerJoinContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object joinSpec();
  Object joinSpecAt(size_t i);
  Object JOIN();
  Object LATERAL();
  Object INNER();
  Object CROSS();
};

class JoinSpecContextProxy : public ContextProxy {
public:
  JoinSpecContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uidList();
  Object ON();
  Object USING();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class NaturalJoinContextProxy : public ContextProxy {
public:
  NaturalJoinContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object NATURAL();
  Object JOIN();
  Object LEFT();
  Object RIGHT();
  Object OUTER();
};

class OuterJoinContextProxy : public ContextProxy {
public:
  OuterJoinContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object joinSpec();
  Object joinSpecAt(size_t i);
  Object JOIN();
  Object LEFT();
  Object RIGHT();
  Object OUTER();
  Object LATERAL();
};

class StraightJoinContextProxy : public ContextProxy {
public:
  StraightJoinContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSourceItem();
  Object expression();
  Object expressionAt(size_t i);
  Object STRAIGHT_JOIN();
  Object ON();
  Object ONAt(size_t i);
};

class SelectElementsContextProxy : public ContextProxy {
public:
  SelectElementsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectElement();
  Object selectElementAt(size_t i);
  Object STAR();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class FromClauseContextProxy : public ContextProxy {
public:
  FromClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableSources();
  Object expression();
  Object FROM();
  Object WHERE();
};

class SelectSpecContextProxy : public ContextProxy {
public:
  SelectSpecContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ALL();
  Object DISTINCT();
  Object DISTINCTROW();
  Object HIGH_PRIORITY();
  Object STRAIGHT_JOIN();
  Object SQL_SMALL_RESULT();
  Object SQL_BIG_RESULT();
  Object SQL_BUFFER_RESULT();
  Object SQL_CACHE();
  Object SQL_NO_CACHE();
  Object SQL_CALC_FOUND_ROWS();
};

class SelectIntoExpressionContextProxy : public ContextProxy {
public:
  SelectIntoExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class GroupByClauseContextProxy : public ContextProxy {
public:
  GroupByClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object groupByItem();
  Object groupByItemAt(size_t i);
  Object GROUP();
  Object BY();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object WITH();
  Object ROLLUP();
};

class HavingClauseContextProxy : public ContextProxy {
public:
  HavingClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object HAVING();
};

class WindowClauseContextProxy : public ContextProxy {
public:
  WindowClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object windowName();
  Object windowNameAt(size_t i);
  Object windowSpec();
  Object windowSpecAt(size_t i);
  Object WINDOW();
  Object AS();
  Object ASAt(size_t i);
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class JsonColumnListContextProxy : public ContextProxy {
public:
  JsonColumnListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object jsonColumn();
  Object jsonColumnAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class JsonColumnContextProxy : public ContextProxy {
public:
  JsonColumnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object dataType();
  Object jsonOnEmpty();
  Object jsonOnError();
  Object jsonColumnList();
  Object FOR();
  Object ORDINALITY();
  Object PATH();
  Object STRING_LITERAL();
  Object EXISTS();
  Object NESTED();
  Object COLUMNS();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class JsonOnEmptyContextProxy : public ContextProxy {
public:
  JsonOnEmptyContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object defaultValue();
  Object ON();
  Object EMPTY();
  Object NULL_LITERAL();
  Object ERROR();
  Object DEFAULT();
};

class JsonOnErrorContextProxy : public ContextProxy {
public:
  JsonOnErrorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object defaultValue();
  Object ON();
  Object ERROR();
  Object ERRORAt(size_t i);
  Object NULL_LITERAL();
  Object DEFAULT();
};

class SelectElementContextProxy : public ContextProxy {
public:
  SelectElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SelectExpressionElementContextProxy : public ContextProxy {
public:
  SelectExpressionElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object LOCAL_ID();
  Object VAR_ASSIGN();
  Object AS();
};

class FunctionCallContextProxy : public ContextProxy {
public:
  FunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SelectFunctionElementContextProxy : public ContextProxy {
public:
  SelectFunctionElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionCall();
  Object uid();
  Object AS();
};

class SelectStarElementContextProxy : public ContextProxy {
public:
  SelectStarElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object DOT();
  Object STAR();
};

class SelectColumnElementContextProxy : public ContextProxy {
public:
  SelectColumnElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object uid();
  Object AS();
};

class SelectIntoVariablesContextProxy : public ContextProxy {
public:
  SelectIntoVariablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object assignmentField();
  Object assignmentFieldAt(size_t i);
  Object INTO();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class SelectIntoTextFileContextProxy : public ContextProxy {
public:
  SelectIntoTextFileContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetName();
  Object selectFieldsInto();
  Object selectFieldsIntoAt(size_t i);
  Object selectLinesInto();
  Object selectLinesIntoAt(size_t i);
  Object INTO();
  Object OUTFILE();
  Object STRING_LITERAL();
  Object CHARACTER();
  Object SET();
  Object LINES();
  Object FIELDS();
  Object COLUMNS();
};

class SelectIntoDumpFileContextProxy : public ContextProxy {
public:
  SelectIntoDumpFileContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object INTO();
  Object DUMPFILE();
  Object STRING_LITERAL();
};

class GroupByItemContextProxy : public ContextProxy {
public:
  GroupByItemContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object ASC();
  Object DESC();
};

class WindowNameContextProxy : public ContextProxy {
public:
  WindowNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();

};

class WindowSpecContextProxy : public ContextProxy {
public:
  WindowSpecContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object windowName();
  Object partitionClause();
  Object orderByClause();
  Object frameClause();

};

class MysqlVariableContextProxy : public ContextProxy {
public:
  MysqlVariableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LOCAL_ID();
  Object GLOBAL_ID();
};

class SimpleIdContextProxy : public ContextProxy {
public:
  SimpleIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetNameBase();
  Object transactionLevelBase();
  Object engineNameBase();
  Object privilegesBase();
  Object intervalTypeBase();
  Object dataTypeBase();
  Object keywordsCanBeId();
  Object scalarFunctionName();
  Object ID();
};

class TransactionModeContextProxy : public ContextProxy {
public:
  TransactionModeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object WITH();
  Object CONSISTENT();
  Object SNAPSHOT();
  Object READ();
  Object WRITE();
  Object ONLY();
};

class LockTableElementContextProxy : public ContextProxy {
public:
  LockTableElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object lockAction();
  Object uid();
  Object AS();
};

class SetAutocommitStatementContextProxy : public ContextProxy {
public:
  SetAutocommitStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SET();
  Object AUTOCOMMIT();
  Object EQUAL_SYMBOL();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
};

class SetTransactionStatementContextProxy : public ContextProxy {
public:
  SetTransactionStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object transactionOption();
  Object transactionOptionAt(size_t i);
  Object SET();
  Object TRANSACTION();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object GLOBAL();
  Object SESSION();
};

class TransactionOptionContextProxy : public ContextProxy {
public:
  TransactionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object transactionLevel();
  Object ISOLATION();
  Object LEVEL();
  Object READ();
  Object WRITE();
  Object ONLY();
};

class LockActionContextProxy : public ContextProxy {
public:
  LockActionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object READ();
  Object LOCAL();
  Object WRITE();
  Object LOW_PRIORITY();
};

class TransactionLevelContextProxy : public ContextProxy {
public:
  TransactionLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object REPEATABLE();
  Object READ();
  Object COMMITTED();
  Object UNCOMMITTED();
  Object SERIALIZABLE();
};

class MasterOptionContextProxy : public ContextProxy {
public:
  MasterOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ChannelOptionContextProxy : public ContextProxy {
public:
  ChannelOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object FOR();
  Object CHANNEL();
  Object STRING_LITERAL();
};

class ReplicationFilterContextProxy : public ContextProxy {
public:
  ReplicationFilterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ThreadTypeContextProxy : public ContextProxy {
public:
  ThreadTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object IO_THREAD();
  Object SQL_THREAD();
};

class UntilOptionContextProxy : public ContextProxy {
public:
  UntilOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ConnectionOptionContextProxy : public ContextProxy {
public:
  ConnectionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class StringMasterOptionContextProxy : public ContextProxy {
public:
  StringMasterOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MASTER_BIND();
  Object MASTER_HOST();
  Object MASTER_USER();
  Object MASTER_PASSWORD();
  Object MASTER_LOG_FILE();
  Object RELAY_LOG_FILE();
  Object MASTER_SSL_CA();
  Object MASTER_SSL_CAPATH();
  Object MASTER_SSL_CERT();
  Object MASTER_SSL_CRL();
  Object MASTER_SSL_CRLPATH();
  Object MASTER_SSL_KEY();
  Object MASTER_SSL_CIPHER();
  Object MASTER_TLS_VERSION();
};

class MasterStringOptionContextProxy : public ContextProxy {
public:
  MasterStringOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringMasterOption();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
};

class MasterRealOptionContextProxy : public ContextProxy {
public:
  MasterRealOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MASTER_HEARTBEAT_PERIOD();
  Object EQUAL_SYMBOL();
  Object REAL_LITERAL();
};

class BoolMasterOptionContextProxy : public ContextProxy {
public:
  BoolMasterOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MASTER_AUTO_POSITION();
  Object MASTER_SSL();
  Object MASTER_SSL_VERIFY_SERVER_CERT();
};

class MasterBoolOptionContextProxy : public ContextProxy {
public:
  MasterBoolOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object boolMasterOption();
  Object EQUAL_SYMBOL();
  Object ZERO_DECIMAL();
  Object ONE_DECIMAL();
};

class MasterUidListOptionContextProxy : public ContextProxy {
public:
  MasterUidListOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object IGNORE_SERVER_IDS();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class DecimalMasterOptionContextProxy : public ContextProxy {
public:
  DecimalMasterOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MASTER_PORT();
  Object MASTER_CONNECT_RETRY();
  Object MASTER_RETRY_COUNT();
  Object MASTER_DELAY();
  Object MASTER_LOG_POS();
  Object RELAY_LOG_POS();
};

class MasterDecimalOptionContextProxy : public ContextProxy {
public:
  MasterDecimalOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalMasterOption();
  Object decimalLiteral();
  Object EQUAL_SYMBOL();
};

class WildIgnoreTableReplicationContextProxy : public ContextProxy {
public:
  WildIgnoreTableReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object simpleStrings();
  Object REPLICATE_WILD_IGNORE_TABLE();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class SimpleStringsContextProxy : public ContextProxy {
public:
  SimpleStringsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class DoTableReplicationContextProxy : public ContextProxy {
public:
  DoTableReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object REPLICATE_DO_TABLE();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class IgnoreTableReplicationContextProxy : public ContextProxy {
public:
  IgnoreTableReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object REPLICATE_IGNORE_TABLE();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class RewriteDbReplicationContextProxy : public ContextProxy {
public:
  RewriteDbReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tablePair();
  Object tablePairAt(size_t i);
  Object REPLICATE_REWRITE_DB();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class TablePairContextProxy : public ContextProxy {
public:
  TablePairContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object tableNameAt(size_t i);
  Object LR_BRACKET();
  Object COMMA();
  Object RR_BRACKET();
};

class DoDbReplicationContextProxy : public ContextProxy {
public:
  DoDbReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object REPLICATE_DO_DB();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class IgnoreDbReplicationContextProxy : public ContextProxy {
public:
  IgnoreDbReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object REPLICATE_IGNORE_DB();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class WildDoTableReplicationContextProxy : public ContextProxy {
public:
  WildDoTableReplicationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object simpleStrings();
  Object REPLICATE_WILD_DO_TABLE();
  Object EQUAL_SYMBOL();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class GtidsUntilOptionContextProxy : public ContextProxy {
public:
  GtidsUntilOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object gtuidSet();
  Object EQUAL_SYMBOL();
  Object SQL_BEFORE_GTIDS();
  Object SQL_AFTER_GTIDS();
};

class GtuidSetContextProxy : public ContextProxy {
public:
  GtuidSetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uuidSet();
  Object uuidSetAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
  Object STRING_LITERAL();
};

class SqlGapsUntilOptionContextProxy : public ContextProxy {
public:
  SqlGapsUntilOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SQL_AFTER_MTS_GAPS();
};

class MasterLogUntilOptionContextProxy : public ContextProxy {
public:
  MasterLogUntilOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MASTER_LOG_FILE();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object STRING_LITERAL();
  Object COMMA();
  Object MASTER_LOG_POS();
};

class RelayLogUntilOptionContextProxy : public ContextProxy {
public:
  RelayLogUntilOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object RELAY_LOG_FILE();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object STRING_LITERAL();
  Object COMMA();
  Object RELAY_LOG_POS();
};

class PluginDirConnectionOptionContextProxy : public ContextProxy {
public:
  PluginDirConnectionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PLUGIN_DIR();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
};

class UserConnectionOptionContextProxy : public ContextProxy {
public:
  UserConnectionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object USER();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
};

class DefaultAuthConnectionOptionContextProxy : public ContextProxy {
public:
  DefaultAuthConnectionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DEFAULT_AUTH();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
};

class PasswordConnectionOptionContextProxy : public ContextProxy {
public:
  PasswordConnectionOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PASSWORD();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
};

class UuidSetContextProxy : public ContextProxy {
public:
  UuidSetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object MINUS();
  Object MINUSAt(size_t i);
  Object COLON_SYMB();
  Object COLON_SYMBAt(size_t i);
};

class XidContextProxy : public ContextProxy {
public:
  XidContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object xuidStringId();
  Object xuidStringIdAt(size_t i);
  Object decimalLiteral();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class UserVariablesContextProxy : public ContextProxy {
public:
  UserVariablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LOCAL_ID();
  Object LOCAL_IDAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class DeclareVariableContextProxy : public ContextProxy {
public:
  DeclareVariableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uidList();
  Object dataType();
  Object expression();
  Object DECLARE();
  Object DEFAULT();
};

class DeclareConditionContextProxy : public ContextProxy {
public:
  DeclareConditionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object decimalLiteral();
  Object DECLARE();
  Object CONDITION();
  Object FOR();
  Object SQLSTATE();
  Object STRING_LITERAL();
  Object VALUE();
};

class DeclareCursorContextProxy : public ContextProxy {
public:
  DeclareCursorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object selectStatement();
  Object DECLARE();
  Object CURSOR();
  Object FOR();
};

class DeclareHandlerContextProxy : public ContextProxy {
public:
  DeclareHandlerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object handlerConditionValue();
  Object handlerConditionValueAt(size_t i);
  Object routineBody();
  Object DECLARE();
  Object HANDLER();
  Object FOR();
  Object CONTINUE();
  Object EXIT();
  Object UNDO();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ProcedureSqlStatementContextProxy : public ContextProxy {
public:
  ProcedureSqlStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object compoundStatement();
  Object sqlStatement();
  Object SEMI();
};

class CaseAlternativeContextProxy : public ContextProxy {
public:
  CaseAlternativeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();
  Object expression();
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object WHEN();
  Object THEN();
};

class ElifAlternativeContextProxy : public ContextProxy {
public:
  ElifAlternativeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object procedureSqlStatement();
  Object procedureSqlStatementAt(size_t i);
  Object ELSEIF();
  Object THEN();
};

class CloseCursorContextProxy : public ContextProxy {
public:
  CloseCursorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object CLOSE();
};

class OpenCursorContextProxy : public ContextProxy {
public:
  OpenCursorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object OPEN();
};

class FetchCursorContextProxy : public ContextProxy {
public:
  FetchCursorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidList();
  Object FETCH();
  Object INTO();
  Object FROM();
  Object NEXT();
};

class HandlerConditionValueContextProxy : public ContextProxy {
public:
  HandlerConditionValueContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class HandlerConditionWarningContextProxy : public ContextProxy {
public:
  HandlerConditionWarningContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SQLWARNING();
};

class HandlerConditionCodeContextProxy : public ContextProxy {
public:
  HandlerConditionCodeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();

};

class HandlerConditionNotfoundContextProxy : public ContextProxy {
public:
  HandlerConditionNotfoundContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object NOT();
  Object FOUND();
};

class HandlerConditionStateContextProxy : public ContextProxy {
public:
  HandlerConditionStateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SQLSTATE();
  Object STRING_LITERAL();
  Object VALUE();
};

class HandlerConditionExceptionContextProxy : public ContextProxy {
public:
  HandlerConditionExceptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SQLEXCEPTION();
};

class HandlerConditionNameContextProxy : public ContextProxy {
public:
  HandlerConditionNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();

};

class AlterUserMysqlV80ContextProxy : public ContextProxy {
public:
  AlterUserMysqlV80ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userAuthOption();
  Object userAuthOptionAt(size_t i);
  Object ifExists();
  Object userPasswordOption();
  Object userPasswordOptionAt(size_t i);
  Object userLockOption();
  Object userLockOptionAt(size_t i);
  Object tlsOption();
  Object tlsOptionAt(size_t i);
  Object userResourceOption();
  Object userResourceOptionAt(size_t i);
  Object roleOption();
  Object userName();
  Object uid();
  Object ALTER();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object REQUIRE();
  Object WITH();
  Object COMMENT();
  Object STRING_LITERAL();
  Object ATTRIBUTE();
  Object NONE();
  Object AND();
  Object ANDAt(size_t i);
  Object DEFAULT();
  Object ROLE();
};

class UserAuthOptionContextProxy : public ContextProxy {
public:
  UserAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class UserPasswordOptionContextProxy : public ContextProxy {
public:
  UserPasswordOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object PASSWORD();
  Object EXPIRE();
  Object DAY();
  Object DEFAULT();
  Object NEVER();
  Object INTERVAL();
  Object HISTORY();
  Object REUSE();
  Object REQUIRE();
  Object CURRENT();
  Object OPTIONAL();
  Object FAILED_LOGIN_ATTEMPTS();
  Object PASSWORD_LOCK_TIME();
  Object UNBOUNDED();
};

class UserLockOptionContextProxy : public ContextProxy {
public:
  UserLockOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ACCOUNT();
  Object LOCK();
  Object UNLOCK();
};

class TlsOptionContextProxy : public ContextProxy {
public:
  TlsOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SSL();
  Object X509();
  Object CIPHER();
  Object STRING_LITERAL();
  Object ISSUER();
  Object SUBJECT();
};

class UserResourceOptionContextProxy : public ContextProxy {
public:
  UserResourceOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object MAX_QUERIES_PER_HOUR();
  Object MAX_UPDATES_PER_HOUR();
  Object MAX_CONNECTIONS_PER_HOUR();
  Object MAX_USER_CONNECTIONS();
};

class AlterUserMysqlV56ContextProxy : public ContextProxy {
public:
  AlterUserMysqlV56ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userSpecification();
  Object userSpecificationAt(size_t i);
  Object ALTER();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class UserSpecificationContextProxy : public ContextProxy {
public:
  UserSpecificationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userPasswordOption();

};

class CreateUserMysqlV56ContextProxy : public ContextProxy {
public:
  CreateUserMysqlV56ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userAuthOption();
  Object userAuthOptionAt(size_t i);
  Object CREATE();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CreateUserMysqlV80ContextProxy : public ContextProxy {
public:
  CreateUserMysqlV80ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userAuthOption();
  Object userAuthOptionAt(size_t i);
  Object ifNotExists();
  Object roleOption();
  Object userPasswordOption();
  Object userPasswordOptionAt(size_t i);
  Object userLockOption();
  Object userLockOptionAt(size_t i);
  Object tlsOption();
  Object tlsOptionAt(size_t i);
  Object userResourceOption();
  Object userResourceOptionAt(size_t i);
  Object CREATE();
  Object USER();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object DEFAULT();
  Object ROLE();
  Object REQUIRE();
  Object WITH();
  Object COMMENT();
  Object STRING_LITERAL();
  Object ATTRIBUTE();
  Object NONE();
  Object AND();
  Object ANDAt(size_t i);
};

class PrivelegeClauseContextProxy : public ContextProxy {
public:
  PrivelegeClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object privilege();
  Object uidList();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class PrivilegeLevelContextProxy : public ContextProxy {
public:
  PrivilegeLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class RenameUserClauseContextProxy : public ContextProxy {
public:
  RenameUserClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object TO();
};

class DetailRevokeContextProxy : public ContextProxy {
public:
  DetailRevokeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object privelegeClause();
  Object privelegeClauseAt(size_t i);
  Object privilegeLevel();
  Object userName();
  Object userNameAt(size_t i);
  Object REVOKE();
  Object ON();
  Object FROM();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object TABLE();
  Object FUNCTION();
  Object PROCEDURE();
};

class RoleRevokeContextProxy : public ContextProxy {
public:
  RoleRevokeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object uid();
  Object uidAt(size_t i);
  Object REVOKE();
  Object FROM();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class ShortRevokeContextProxy : public ContextProxy {
public:
  ShortRevokeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object userNameAt(size_t i);
  Object REVOKE();
  Object ALL();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object GRANT();
  Object OPTION();
  Object FROM();
  Object PRIVILEGES();
};

class SetPasswordStatementContextProxy : public ContextProxy {
public:
  SetPasswordStatementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object passwordFunctionClause();
  Object userName();
  Object SET();
  Object PASSWORD();
  Object EQUAL_SYMBOL();
  Object STRING_LITERAL();
  Object FOR();
};

class PasswordFunctionClauseContextProxy : public ContextProxy {
public:
  PasswordFunctionClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionArg();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object PASSWORD();
  Object OLD_PASSWORD();
};

class SimpleAuthOptionContextProxy : public ContextProxy {
public:
  SimpleAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();

};

class ModuleAuthOptionContextProxy : public ContextProxy {
public:
  ModuleAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object authenticationRule();
  Object IDENTIFIED();
  Object WITH();
};

class AuthenticationRuleContextProxy : public ContextProxy {
public:
  AuthenticationRuleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class RandomAuthOptionContextProxy : public ContextProxy {
public:
  RandomAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object authOptionClause();
  Object IDENTIFIED();
  Object BY();
  Object RANDOM();
  Object PASSWORD();
};

class AuthOptionClauseContextProxy : public ContextProxy {
public:
  AuthOptionClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object REPLACE();
  Object STRING_LITERAL();
  Object RETAIN();
  Object CURRENT();
  Object PASSWORD();
};

class StringAuthOptionContextProxy : public ContextProxy {
public:
  StringAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object authOptionClause();
  Object IDENTIFIED();
  Object BY();
  Object STRING_LITERAL();
};

class HashAuthOptionContextProxy : public ContextProxy {
public:
  HashAuthOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object IDENTIFIED();
  Object BY();
  Object PASSWORD();
  Object STRING_LITERAL();
};

class AuthPluginContextProxy : public ContextProxy {
public:
  AuthPluginContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object STRING_LITERAL();
};

class PasswordModuleOptionContextProxy : public ContextProxy {
public:
  PasswordModuleOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object authPlugin();
  Object passwordFunctionClause();
  Object USING();
};

class ModuleContextProxy : public ContextProxy {
public:
  ModuleContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object authPlugin();
  Object authOptionClause();
  Object BY();
  Object USING();
  Object AS();
  Object STRING_LITERAL();
  Object RANDOM();
  Object PASSWORD();
};

class PrivilegeContextProxy : public ContextProxy {
public:
  PrivilegeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ALL();
  Object PRIVILEGES();
  Object ALTER();
  Object ROUTINE();
  Object CREATE();
  Object TEMPORARY();
  Object TABLES();
  Object VIEW();
  Object USER();
  Object TABLESPACE();
  Object ROLE();
  Object DELETE();
  Object DROP();
  Object EVENT();
  Object EXECUTE();
  Object FILE();
  Object GRANT();
  Object OPTION();
  Object INDEX();
  Object INSERT();
  Object LOCK();
  Object PROCESS();
  Object PROXY();
  Object REFERENCES();
  Object RELOAD();
  Object REPLICATION();
  Object CLIENT();
  Object SLAVE();
  Object SELECT();
  Object SHOW();
  Object DATABASES();
  Object SHUTDOWN();
  Object SUPER();
  Object TRIGGER();
  Object UPDATE();
  Object USAGE();
  Object APPLICATION_PASSWORD_ADMIN();
  Object AUDIT_ABORT_EXEMPT();
  Object AUDIT_ADMIN();
  Object AUTHENTICATION_POLICY_ADMIN();
  Object BACKUP_ADMIN();
  Object BINLOG_ADMIN();
  Object BINLOG_ENCRYPTION_ADMIN();
  Object CLONE_ADMIN();
  Object CONNECTION_ADMIN();
  Object ENCRYPTION_KEY_ADMIN();
  Object FIREWALL_ADMIN();
  Object FIREWALL_EXEMPT();
  Object FIREWALL_USER();
  Object FLUSH_OPTIMIZER_COSTS();
  Object FLUSH_STATUS();
  Object FLUSH_TABLES();
  Object FLUSH_USER_RESOURCES();
  Object GROUP_REPLICATION_ADMIN();
  Object INNODB_REDO_LOG_ARCHIVE();
  Object INNODB_REDO_LOG_ENABLE();
  Object NDB_STORED_USER();
  Object PASSWORDLESS_USER_ADMIN();
  Object PERSIST_RO_VARIABLES_ADMIN();
  Object REPLICATION_APPLIER();
  Object REPLICATION_SLAVE_ADMIN();
  Object RESOURCE_GROUP_ADMIN();
  Object RESOURCE_GROUP_USER();
  Object ROLE_ADMIN();
  Object SERVICE_CONNECTION_ADMIN();
  Object SESSION_VARIABLES_ADMIN();
  Object SET_USER_ID();
  Object SKIP_QUERY_REWRITE();
  Object SHOW_ROUTINE();
  Object SYSTEM_USER();
  Object SYSTEM_VARIABLES_ADMIN();
  Object TABLE_ENCRYPTION_ADMIN();
  Object TP_CONNECTION_ADMIN();
  Object VERSION_TOKEN_ADMIN();
  Object XA_RECOVER_ADMIN();
  Object LOAD();
  Object FROM();
  Object S3();
  Object INTO();
  Object INVOKE();
  Object LAMBDA();
};

class DefiniteSchemaPrivLevelContextProxy : public ContextProxy {
public:
  DefiniteSchemaPrivLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DOT();
  Object STAR();
};

class DefiniteFullTablePrivLevel2ContextProxy : public ContextProxy {
public:
  DefiniteFullTablePrivLevel2ContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object dottedId();

};

class DottedIdContextProxy : public ContextProxy {
public:
  DottedIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object DOT_ID();
  Object DOT();
};

class DefiniteFullTablePrivLevelContextProxy : public ContextProxy {
public:
  DefiniteFullTablePrivLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object uidAt(size_t i);
  Object DOT();
};

class GlobalPrivLevelContextProxy : public ContextProxy {
public:
  GlobalPrivLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STAR();
  Object STARAt(size_t i);
  Object DOT();
};

class DefiniteTablePrivLevelContextProxy : public ContextProxy {
public:
  DefiniteTablePrivLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();

};

class CurrentSchemaPriviLevelContextProxy : public ContextProxy {
public:
  CurrentSchemaPriviLevelContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STAR();
};

class CheckTableOptionContextProxy : public ContextProxy {
public:
  CheckTableOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object FOR();
  Object UPGRADE();
  Object QUICK();
  Object FAST();
  Object MEDIUM();
  Object EXTENDED();
  Object CHANGED();
};

class SetTransactionContextProxy : public ContextProxy {
public:
  SetTransactionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object setTransactionStatement();

};

class SetCharsetContextProxy : public ContextProxy {
public:
  SetCharsetContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charSet();
  Object charsetName();
  Object SET();
  Object DEFAULT();
};

class SetNamesContextProxy : public ContextProxy {
public:
  SetNamesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charsetName();
  Object collationName();
  Object SET();
  Object NAMES();
  Object DEFAULT();
  Object COLLATE();
};

class SetPasswordContextProxy : public ContextProxy {
public:
  SetPasswordContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object setPasswordStatement();

};

class SetAutocommitContextProxy : public ContextProxy {
public:
  SetAutocommitContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object setAutocommitStatement();

};

class SetNewValueInsideTriggerContextProxy : public ContextProxy {
public:
  SetNewValueInsideTriggerContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object fullIdAt(size_t i);
  Object expression();
  Object expressionAt(size_t i);
  Object SET();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object VAR_ASSIGN();
  Object VAR_ASSIGNAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class SetVariableContextProxy : public ContextProxy {
public:
  SetVariableContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object variableClause();
  Object variableClauseAt(size_t i);
  Object expression();
  Object expressionAt(size_t i);
  Object SET();
  Object EQUAL_SYMBOL();
  Object EQUAL_SYMBOLAt(size_t i);
  Object VAR_ASSIGN();
  Object VAR_ASSIGNAt(size_t i);
  Object ON();
  Object ONAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class VariableClauseContextProxy : public ContextProxy {
public:
  VariableClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object LOCAL_ID();
  Object GLOBAL_ID();
  Object GLOBAL();
  Object SESSION();
  Object LOCAL();
  Object AT_SIGN();
  Object AT_SIGNAt(size_t i);
};

class ShowOpenTablesContextProxy : public ContextProxy {
public:
  ShowOpenTablesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object showFilter();
  Object SHOW();
  Object OPEN();
  Object TABLES();
  Object FROM();
  Object IN();
};

class ShowFilterContextProxy : public ContextProxy {
public:
  ShowFilterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object LIKE();
  Object STRING_LITERAL();
  Object WHERE();
};

class ShowGlobalInfoContextProxy : public ContextProxy {
public:
  ShowGlobalInfoContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object showGlobalInfoClause();
  Object SHOW();
};

class ShowGlobalInfoClauseContextProxy : public ContextProxy {
public:
  ShowGlobalInfoClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ENGINES();
  Object STORAGE();
  Object MASTER();
  Object STATUS();
  Object PLUGINS();
  Object PRIVILEGES();
  Object PROCESSLIST();
  Object FULL();
  Object PROFILES();
  Object SLAVE();
  Object HOSTS();
  Object AUTHORS();
  Object CONTRIBUTORS();
};

class ShowCreateFullIdObjectContextProxy : public ContextProxy {
public:
  ShowCreateFullIdObjectContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object SHOW();
  Object CREATE();
  Object EVENT();
  Object FUNCTION();
  Object PROCEDURE();
  Object TABLE();
  Object TRIGGER();
  Object VIEW();
};

class ShowCreateUserContextProxy : public ContextProxy {
public:
  ShowCreateUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object SHOW();
  Object CREATE();
  Object USER();
};

class ShowErrorsContextProxy : public ContextProxy {
public:
  ShowErrorsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object SHOW();
  Object ERRORS();
  Object WARNINGS();
  Object LIMIT();
  Object COMMA();
};

class ShowCountErrorsContextProxy : public ContextProxy {
public:
  ShowCountErrorsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SHOW();
  Object COUNT();
  Object LR_BRACKET();
  Object STAR();
  Object RR_BRACKET();
  Object ERRORS();
  Object WARNINGS();
};

class ShowObjectFilterContextProxy : public ContextProxy {
public:
  ShowObjectFilterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object showCommonEntity();
  Object showFilter();
  Object SHOW();
};

class ShowCommonEntityContextProxy : public ContextProxy {
public:
  ShowCommonEntityContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CHARACTER();
  Object SET();
  Object COLLATION();
  Object DATABASES();
  Object SCHEMAS();
  Object FUNCTION();
  Object STATUS();
  Object PROCEDURE();
  Object VARIABLES();
  Object GLOBAL();
  Object SESSION();
};

class ShowCreateDbContextProxy : public ContextProxy {
public:
  ShowCreateDbContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object ifNotExists();
  Object SHOW();
  Object CREATE();
  Object DATABASE();
  Object SCHEMA();
};

class ShowEngineContextProxy : public ContextProxy {
public:
  ShowEngineContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object engineName();
  Object SHOW();
  Object ENGINE();
  Object STATUS();
  Object MUTEX();
};

class ShowSchemaFilterContextProxy : public ContextProxy {
public:
  ShowSchemaFilterContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object showSchemaEntity();
  Object uid();
  Object showFilter();
  Object SHOW();
  Object FROM();
  Object IN();
};

class ShowSchemaEntityContextProxy : public ContextProxy {
public:
  ShowSchemaEntityContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object EVENTS();
  Object TABLE();
  Object STATUS();
  Object TABLES();
  Object FULL();
  Object TRIGGERS();
};

class ShowIndexesContextProxy : public ContextProxy {
public:
  ShowIndexesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object expression();
  Object SHOW();
  Object INDEX();
  Object INDEXES();
  Object KEYS();
  Object FROM();
  Object FROMAt(size_t i);
  Object IN();
  Object INAt(size_t i);
  Object WHERE();
};

class ShowLogEventsContextProxy : public ContextProxy {
public:
  ShowLogEventsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object SHOW();
  Object EVENTS();
  Object BINLOG();
  Object RELAYLOG();
  Object IN();
  Object FROM();
  Object LIMIT();
  Object STRING_LITERAL();
  Object COMMA();
};

class ShowMasterLogsContextProxy : public ContextProxy {
public:
  ShowMasterLogsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SHOW();
  Object LOGS();
  Object BINARY();
  Object MASTER();
};

class ShowGrantsContextProxy : public ContextProxy {
public:
  ShowGrantsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object userName();
  Object SHOW();
  Object GRANTS();
  Object FOR();
};

class ShowSlaveStatusContextProxy : public ContextProxy {
public:
  ShowSlaveStatusContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object SHOW();
  Object SLAVE();
  Object STATUS();
  Object FOR();
  Object CHANNEL();
  Object STRING_LITERAL();
};

class ShowRoutineContextProxy : public ContextProxy {
public:
  ShowRoutineContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object SHOW();
  Object CODE();
  Object FUNCTION();
  Object PROCEDURE();
};

class ShowProfileContextProxy : public ContextProxy {
public:
  ShowProfileContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object showProfileType();
  Object showProfileTypeAt(size_t i);
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object SHOW();
  Object PROFILE();
  Object LIMIT();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object FOR();
  Object QUERY();
};

class ShowProfileTypeContextProxy : public ContextProxy {
public:
  ShowProfileTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ALL();
  Object BLOCK();
  Object IO();
  Object CONTEXT();
  Object SWITCHES();
  Object CPU();
  Object IPC();
  Object MEMORY();
  Object PAGE();
  Object FAULTS();
  Object SOURCE();
  Object SWAPS();
};

class ShowColumnsContextProxy : public ContextProxy {
public:
  ShowColumnsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uid();
  Object showFilter();
  Object SHOW();
  Object COLUMNS();
  Object FIELDS();
  Object FROM();
  Object FROMAt(size_t i);
  Object IN();
  Object INAt(size_t i);
  Object FULL();
};

class TableIndexesContextProxy : public ContextProxy {
public:
  TableIndexesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uidList();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object INDEX();
  Object KEY();
};

class FlushOptionContextProxy : public ContextProxy {
public:
  FlushOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class LoadedTableIndexesContextProxy : public ContextProxy {
public:
  LoadedTableIndexesContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tableName();
  Object uidList();
  Object uidListAt(size_t i);
  Object PARTITION();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object IGNORE();
  Object LEAVES();
  Object ALL();
  Object INDEX();
  Object KEY();
};

class TableFlushOptionContextProxy : public ContextProxy {
public:
  TableFlushOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object tables();
  Object flushTableOption();
  Object TABLE();
  Object TABLES();
};

class FlushTableOptionContextProxy : public ContextProxy {
public:
  FlushTableOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object WITH();
  Object READ();
  Object LOCK();
  Object FOR();
  Object EXPORT();
};

class ChannelFlushOptionContextProxy : public ContextProxy {
public:
  ChannelFlushOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object channelOption();
  Object RELAY();
  Object LOGS();
};

class SimpleFlushOptionContextProxy : public ContextProxy {
public:
  SimpleFlushOptionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DES_KEY_FILE();
  Object HOSTS();
  Object LOGS();
  Object OPTIMIZER_COSTS();
  Object PRIVILEGES();
  Object QUERY();
  Object CACHE();
  Object STATUS();
  Object USER_RESOURCES();
  Object TABLES();
  Object WITH();
  Object READ();
  Object LOCK();
  Object BINARY();
  Object ENGINE();
  Object ERROR();
  Object GENERAL();
  Object RELAY();
  Object SLOW();
};

class DescribeObjectClauseContextProxy : public ContextProxy {
public:
  DescribeObjectClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SignalConditionInformationContextProxy : public ContextProxy {
public:
  SignalConditionInformationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object mysqlVariable();
  Object simpleId();
  Object EQUAL_SYMBOL();
  Object CLASS_ORIGIN();
  Object SUBCLASS_ORIGIN();
  Object MESSAGE_TEXT();
  Object MYSQL_ERRNO();
  Object CONSTRAINT_CATALOG();
  Object CONSTRAINT_SCHEMA();
  Object CONSTRAINT_NAME();
  Object CATALOG_NAME();
  Object SCHEMA_NAME();
  Object TABLE_NAME();
  Object COLUMN_NAME();
  Object CURSOR_NAME();
  Object DECIMAL_LITERAL();
};

class DiagnosticsConditionInformationNameContextProxy : public ContextProxy {
public:
  DiagnosticsConditionInformationNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CLASS_ORIGIN();
  Object SUBCLASS_ORIGIN();
  Object RETURNED_SQLSTATE();
  Object MESSAGE_TEXT();
  Object MYSQL_ERRNO();
  Object CONSTRAINT_CATALOG();
  Object CONSTRAINT_SCHEMA();
  Object CONSTRAINT_NAME();
  Object CATALOG_NAME();
  Object SCHEMA_NAME();
  Object TABLE_NAME();
  Object COLUMN_NAME();
  Object CURSOR_NAME();
};

class DescribeStatementsContextProxy : public ContextProxy {
public:
  DescribeStatementsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectStatement();
  Object deleteStatement();
  Object insertStatement();
  Object replaceStatement();
  Object updateStatement();

};

class DescribeConnectionContextProxy : public ContextProxy {
public:
  DescribeConnectionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object uid();
  Object FOR();
  Object CONNECTION();
};

class IndexColumnNameContextProxy : public ContextProxy {
public:
  IndexColumnNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object uid();
  Object decimalLiteral();
  Object STRING_LITERAL();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object ASC();
  Object DESC();
};

class SimpleUserNameContextProxy : public ContextProxy {
public:
  SimpleUserNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object keywordsCanBeId();
  Object STRING_LITERAL();
  Object ID();
  Object ADMIN();
};

class KeywordsCanBeIdContextProxy : public ContextProxy {
public:
  KeywordsCanBeIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ACCOUNT();
  Object ACTION();
  Object ADMIN();
  Object AFTER();
  Object AGGREGATE();
  Object ALGORITHM();
  Object ANY();
  Object ARRAY();
  Object AT();
  Object AUDIT_ADMIN();
  Object AUDIT_ABORT_EXEMPT();
  Object AUTHORS();
  Object AUTOCOMMIT();
  Object AUTOEXTEND_SIZE();
  Object AUTO_INCREMENT();
  Object AUTHENTICATION_POLICY_ADMIN();
  Object AVG();
  Object AVG_ROW_LENGTH();
  Object ATTRIBUTE();
  Object BACKUP_ADMIN();
  Object BEGIN();
  Object BINLOG();
  Object BINLOG_ADMIN();
  Object BINLOG_ENCRYPTION_ADMIN();
  Object BIT();
  Object BIT_AND();
  Object BIT_OR();
  Object BIT_XOR();
  Object BLOCK();
  Object BOOL();
  Object BOOLEAN();
  Object BTREE();
  Object BUCKETS();
  Object CACHE();
  Object CASCADED();
  Object CHAIN();
  Object CHANGED();
  Object CHANNEL();
  Object CHECKSUM();
  Object PAGE_CHECKSUM();
  Object CATALOG_NAME();
  Object CIPHER();
  Object CLASS_ORIGIN();
  Object CLIENT();
  Object CLONE_ADMIN();
  Object CLOSE();
  Object CLUSTERING();
  Object COALESCE();
  Object CODE();
  Object COLUMNS();
  Object COLUMN_FORMAT();
  Object COLUMN_NAME();
  Object COMMENT();
  Object COMMIT();
  Object COMPACT();
  Object COMPLETION();
  Object COMPRESSED();
  Object COMPRESSION();
  Object CONCURRENT();
  Object CONDITION();
  Object CONNECT();
  Object CONNECTION();
  Object CONNECTION_ADMIN();
  Object CONSISTENT();
  Object CONSTRAINT_CATALOG();
  Object CONSTRAINT_NAME();
  Object CONSTRAINT_SCHEMA();
  Object CONTAINS();
  Object CONTEXT();
  Object CONTRIBUTORS();
  Object COPY();
  Object COUNT();
  Object CPU();
  Object CURRENT();
  Object CURRENT_USER();
  Object CURSOR_NAME();
  Object DATA();
  Object DATAFILE();
  Object DEALLOCATE();
  Object DEFAULT();
  Object DEFAULT_AUTH();
  Object DEFINER();
  Object DELAY_KEY_WRITE();
  Object DES_KEY_FILE();
  Object DIAGNOSTICS();
  Object DIRECTORY();
  Object DISABLE();
  Object DISCARD();
  Object DISK();
  Object DO();
  Object DUMPFILE();
  Object DUPLICATE();
  Object DYNAMIC();
  Object EMPTY();
  Object ENABLE();
  Object ENCRYPTION();
  Object ENCRYPTION_KEY_ADMIN();
  Object END();
  Object ENDS();
  Object ENGINE();
  Object ENGINE_ATTRIBUTE();
  Object ENGINES();
  Object ENFORCED();
  Object ERROR();
  Object ERRORS();
  Object ESCAPE();
  Object EUR();
  Object EVEN();
  Object EVENT();
  Object EVENTS();
  Object EVERY();
  Object EXCEPT();
  Object EXCHANGE();
  Object EXCLUSIVE();
  Object EXPIRE();
  Object EXPORT();
  Object EXTENDED();
  Object EXTENT_SIZE();
  Object FAILED_LOGIN_ATTEMPTS();
  Object FAST();
  Object FAULTS();
  Object FIELDS();
  Object FILE_BLOCK_SIZE();
  Object FILTER();
  Object FIREWALL_ADMIN();
  Object FIREWALL_EXEMPT();
  Object FIREWALL_USER();
  Object FIRST();
  Object FIXED();
  Object FLUSH();
  Object FOLLOWS();
  Object FOUND();
  Object FULL();
  Object FUNCTION();
  Object GENERAL();
  Object GLOBAL();
  Object GRANTS();
  Object GROUP();
  Object GROUP_CONCAT();
  Object GROUP_REPLICATION();
  Object GROUP_REPLICATION_ADMIN();
  Object HANDLER();
  Object HASH();
  Object HELP();
  Object HISTORY();
  Object HOST();
  Object HOSTS();
  Object IDENTIFIED();
  Object IGNORED();
  Object IGNORE_SERVER_IDS();
  Object IMPORT();
  Object INDEXES();
  Object INITIAL_SIZE();
  Object INNODB_REDO_LOG_ARCHIVE();
  Object INPLACE();
  Object INSERT_METHOD();
  Object INSTALL();
  Object INSTANCE();
  Object INSTANT();
  Object INTERNAL();
  Object INVOKE();
  Object INVOKER();
  Object IO();
  Object IO_THREAD();
  Object IPC();
  Object ISO();
  Object ISOLATION();
  Object ISSUER();
  Object JIS();
  Object JSON();
  Object KEY_BLOCK_SIZE();
  Object LAMBDA();
  Object LANGUAGE();
  Object LAST();
  Object LATERAL();
  Object LEAVES();
  Object LESS();
  Object LEVEL();
  Object LIST();
  Object LOCAL();
  Object LOGFILE();
  Object LOGS();
  Object MASTER();
  Object MASTER_AUTO_POSITION();
  Object MASTER_CONNECT_RETRY();
  Object MASTER_DELAY();
  Object MASTER_HEARTBEAT_PERIOD();
  Object MASTER_HOST();
  Object MASTER_LOG_FILE();
  Object MASTER_LOG_POS();
  Object MASTER_PASSWORD();
  Object MASTER_PORT();
  Object MASTER_RETRY_COUNT();
  Object MASTER_SSL();
  Object MASTER_SSL_CA();
  Object MASTER_SSL_CAPATH();
  Object MASTER_SSL_CERT();
  Object MASTER_SSL_CIPHER();
  Object MASTER_SSL_CRL();
  Object MASTER_SSL_CRLPATH();
  Object MASTER_SSL_KEY();
  Object MASTER_TLS_VERSION();
  Object MASTER_USER();
  Object MAX_CONNECTIONS_PER_HOUR();
  Object MAX_QUERIES_PER_HOUR();
  Object MAX();
  Object MAX_ROWS();
  Object MAX_SIZE();
  Object MAX_UPDATES_PER_HOUR();
  Object MAX_USER_CONNECTIONS();
  Object MEDIUM();
  Object MEMBER();
  Object MEMORY();
  Object MERGE();
  Object MESSAGE_TEXT();
  Object MID();
  Object MIGRATE();
  Object MIN();
  Object MIN_ROWS();
  Object MODE();
  Object MODIFY();
  Object MUTEX();
  Object MYSQL();
  Object MYSQL_ERRNO();
  Object NAME();
  Object NAMES();
  Object NCHAR();
  Object NDB_STORED_USER();
  Object NESTED();
  Object NEVER();
  Object NEXT();
  Object NO();
  Object NOCOPY();
  Object NODEGROUP();
  Object NONE();
  Object NOWAIT();
  Object NUMBER();
  Object ODBC();
  Object OFFLINE();
  Object OFFSET();
  Object OF();
  Object OJ();
  Object OLD_PASSWORD();
  Object ONE();
  Object ONLINE();
  Object ONLY();
  Object OPEN();
  Object OPTIMIZER_COSTS();
  Object OPTIONAL();
  Object OPTIONS();
  Object ORDER();
  Object ORDINALITY();
  Object OWNER();
  Object PACK_KEYS();
  Object PAGE();
  Object PARSER();
  Object PARTIAL();
  Object PARTITIONING();
  Object PARTITIONS();
  Object PASSWORD();
  Object PASSWORDLESS_USER_ADMIN();
  Object PASSWORD_LOCK_TIME();
  Object PATH();
  Object PERSIST_RO_VARIABLES_ADMIN();
  Object PHASE();
  Object PLUGINS();
  Object PLUGIN_DIR();
  Object PLUGIN();
  Object PORT();
  Object PRECEDES();
  Object PREPARE();
  Object PRESERVE();
  Object PREV();
  Object PRIMARY();
  Object PROCESSLIST();
  Object PROFILE();
  Object PROFILES();
  Object PROXY();
  Object QUERY();
  Object QUICK();
  Object REBUILD();
  Object RECOVER();
  Object RECURSIVE();
  Object REDO_BUFFER_SIZE();
  Object REDUNDANT();
  Object RELAY();
  Object RELAYLOG();
  Object RELAY_LOG_FILE();
  Object RELAY_LOG_POS();
  Object REMOVE();
  Object REORGANIZE();
  Object REPAIR();
  Object REPLICATE_DO_DB();
  Object REPLICATE_DO_TABLE();
  Object REPLICATE_IGNORE_DB();
  Object REPLICATE_IGNORE_TABLE();
  Object REPLICATE_REWRITE_DB();
  Object REPLICATE_WILD_DO_TABLE();
  Object REPLICATE_WILD_IGNORE_TABLE();
  Object REPLICATION();
  Object REPLICATION_APPLIER();
  Object REPLICATION_SLAVE_ADMIN();
  Object RESET();
  Object RESOURCE_GROUP_ADMIN();
  Object RESOURCE_GROUP_USER();
  Object RESUME();
  Object RETURNED_SQLSTATE();
  Object RETURNING();
  Object RETURNS();
  Object REUSE();
  Object ROLE();
  Object ROLE_ADMIN();
  Object ROLLBACK();
  Object ROLLUP();
  Object ROTATE();
  Object ROW();
  Object ROWS();
  Object ROW_FORMAT();
  Object RTREE();
  Object S3();
  Object SAVEPOINT();
  Object SCHEDULE();
  Object SCHEMA_NAME();
  Object SECURITY();
  Object SECONDARY_ENGINE_ATTRIBUTE();
  Object SERIAL();
  Object SERVER();
  Object SESSION();
  Object SESSION_VARIABLES_ADMIN();
  Object SET_USER_ID();
  Object SHARE();
  Object SHARED();
  Object SHOW_ROUTINE();
  Object SIGNED();
  Object SIMPLE();
  Object SLAVE();
  Object SLOW();
  Object SKIP_QUERY_REWRITE();
  Object SNAPSHOT();
  Object SOCKET();
  Object SOME();
  Object SONAME();
  Object SOUNDS();
  Object SOURCE();
  Object SQL_AFTER_GTIDS();
  Object SQL_AFTER_MTS_GAPS();
  Object SQL_BEFORE_GTIDS();
  Object SQL_BUFFER_RESULT();
  Object SQL_CACHE();
  Object SQL_NO_CACHE();
  Object SQL_THREAD();
  Object STACKED();
  Object START();
  Object STARTS();
  Object STATS_AUTO_RECALC();
  Object STATS_PERSISTENT();
  Object STATS_SAMPLE_PAGES();
  Object STATUS();
  Object STD();
  Object STDDEV();
  Object STDDEV_POP();
  Object STDDEV_SAMP();
  Object STOP();
  Object STORAGE();
  Object STRING();
  Object SUBCLASS_ORIGIN();
  Object SUBJECT();
  Object SUBPARTITION();
  Object SUBPARTITIONS();
  Object SUM();
  Object SUSPEND();
  Object SWAPS();
  Object SWITCHES();
  Object SYSTEM_VARIABLES_ADMIN();
  Object TABLE_NAME();
  Object TABLESPACE();
  Object TABLE_ENCRYPTION_ADMIN();
  Object TABLE_TYPE();
  Object TEMPORARY();
  Object TEMPTABLE();
  Object THAN();
  Object TP_CONNECTION_ADMIN();
  Object TRADITIONAL();
  Object TRANSACTION();
  Object TRANSACTIONAL();
  Object TRIGGERS();
  Object TRUNCATE();
  Object UNBOUNDED();
  Object UNDEFINED();
  Object UNDOFILE();
  Object UNDO_BUFFER_SIZE();
  Object UNINSTALL();
  Object UNKNOWN();
  Object UNTIL();
  Object UPGRADE();
  Object USA();
  Object USER();
  Object USE_FRM();
  Object USER_RESOURCES();
  Object VALIDATION();
  Object VALUE();
  Object VAR_POP();
  Object VAR_SAMP();
  Object VARIABLES();
  Object VARIANCE();
  Object VERSION_TOKEN_ADMIN();
  Object VIEW();
  Object VIRTUAL();
  Object WAIT();
  Object WARNINGS();
  Object WITHOUT();
  Object WORK();
  Object WRAPPER();
  Object X509();
  Object XA();
  Object XA_RECOVER_ADMIN();
  Object XML();
};

class HostNameContextProxy : public ContextProxy {
public:
  HostNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LOCAL_ID();
  Object HOST_IP_ADDRESS();
  Object AT_SIGN();
};

class CharsetNameBaseContextProxy : public ContextProxy {
public:
  CharsetNameBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ARMSCII8();
  Object ASCII();
  Object BIG5();
  Object BINARY();
  Object CP1250();
  Object CP1251();
  Object CP1256();
  Object CP1257();
  Object CP850();
  Object CP852();
  Object CP866();
  Object CP932();
  Object DEC8();
  Object EUCJPMS();
  Object EUCKR();
  Object GB18030();
  Object GB2312();
  Object GBK();
  Object GEOSTD8();
  Object GREEK();
  Object HEBREW();
  Object HP8();
  Object KEYBCS2();
  Object KOI8R();
  Object KOI8U();
  Object LATIN1();
  Object LATIN2();
  Object LATIN5();
  Object LATIN7();
  Object MACCE();
  Object MACROMAN();
  Object SJIS();
  Object SWE7();
  Object TIS620();
  Object UCS2();
  Object UJIS();
  Object UTF16();
  Object UTF16LE();
  Object UTF32();
  Object UTF8();
  Object UTF8MB3();
  Object UTF8MB4();
};

class EngineNameBaseContextProxy : public ContextProxy {
public:
  EngineNameBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ARCHIVE();
  Object BLACKHOLE();
  Object CONNECT();
  Object CSV();
  Object FEDERATED();
  Object INNODB();
  Object MEMORY();
  Object MRG_MYISAM();
  Object MYISAM();
  Object NDB();
  Object NDBCLUSTER();
  Object PERFORMANCE_SCHEMA();
  Object TOKUDB();
};

class XuidStringIdContextProxy : public ContextProxy {
public:
  XuidStringIdContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STRING_LITERAL();
  Object BIT_STRING();
  Object HEXADECIMAL_LITERAL();
  Object HEXADECIMAL_LITERALAt(size_t i);
};

class TransactionLevelBaseContextProxy : public ContextProxy {
public:
  TransactionLevelBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object REPEATABLE();
  Object COMMITTED();
  Object UNCOMMITTED();
  Object SERIALIZABLE();
};

class PrivilegesBaseContextProxy : public ContextProxy {
public:
  PrivilegesBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object TABLES();
  Object ROUTINE();
  Object EXECUTE();
  Object FILE();
  Object PROCESS();
  Object RELOAD();
  Object SHUTDOWN();
  Object SUPER();
  Object PRIVILEGES();
};

class DataTypeBaseContextProxy : public ContextProxy {
public:
  DataTypeBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DATE();
  Object TIME();
  Object TIMESTAMP();
  Object DATETIME();
  Object YEAR();
  Object ENUM();
  Object TEXT();
};

class ScalarFunctionNameContextProxy : public ContextProxy {
public:
  ScalarFunctionNameContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionNameBase();
  Object ASCII();
  Object CURDATE();
  Object CURRENT_DATE();
  Object CURRENT_TIME();
  Object CURRENT_TIMESTAMP();
  Object CURTIME();
  Object DATE_ADD();
  Object DATE_SUB();
  Object IF();
  Object INSERT();
  Object LOCALTIME();
  Object LOCALTIMESTAMP();
  Object MID();
  Object NOW();
  Object REPEAT();
  Object REPLACE();
  Object SUBSTR();
  Object SUBSTRING();
  Object SYSDATE();
  Object TRIM();
  Object UTC_DATE();
  Object UTC_TIME();
  Object UTC_TIMESTAMP();
};

class BooleanLiteralContextProxy : public ContextProxy {
public:
  BooleanLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object TRUE();
  Object FALSE();
};

class HexadecimalLiteralContextProxy : public ContextProxy {
public:
  HexadecimalLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object HEXADECIMAL_LITERAL();
  Object STRING_CHARSET_NAME();
};

class SpatialDataTypeContextProxy : public ContextProxy {
public:
  SpatialDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object GEOMETRYCOLLECTION();
  Object GEOMCOLLECTION();
  Object LINESTRING();
  Object MULTILINESTRING();
  Object MULTIPOINT();
  Object MULTIPOLYGON();
  Object POINT();
  Object POLYGON();
  Object JSON();
  Object GEOMETRY();
  Object SRID();
};

class LongVarbinaryDataTypeContextProxy : public ContextProxy {
public:
  LongVarbinaryDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LONG();
  Object VARBINARY();
};

class CollectionOptionsContextProxy : public ContextProxy {
public:
  CollectionOptionsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LR_BRACKET();
  Object STRING_LITERAL();
  Object STRING_LITERALAt(size_t i);
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class CollectionDataTypeContextProxy : public ContextProxy {
public:
  CollectionDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object collectionOptions();
  Object charSet();
  Object charsetName();
  Object ENUM();
  Object SET();
  Object BINARY();
};

class NationalVaryingStringDataTypeContextProxy : public ContextProxy {
public:
  NationalVaryingStringDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lengthOneDimension();
  Object NATIONAL();
  Object VARYING();
  Object CHAR();
  Object CHARACTER();
  Object BINARY();
};

class LengthOneDimensionContextProxy : public ContextProxy {
public:
  LengthOneDimensionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class DimensionDataTypeContextProxy : public ContextProxy {
public:
  DimensionDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lengthOneDimension();
  Object lengthTwoDimension();
  Object lengthTwoOptionalDimension();
  Object TINYINT();
  Object SMALLINT();
  Object MEDIUMINT();
  Object INT();
  Object INTEGER();
  Object BIGINT();
  Object MIDDLEINT();
  Object INT1();
  Object INT2();
  Object INT3();
  Object INT4();
  Object INT8();
  Object SIGNED();
  Object SIGNEDAt(size_t i);
  Object UNSIGNED();
  Object UNSIGNEDAt(size_t i);
  Object ZEROFILL();
  Object ZEROFILLAt(size_t i);
  Object REAL();
  Object DOUBLE();
  Object PRECISION();
  Object DECIMAL();
  Object DEC();
  Object FIXED();
  Object NUMERIC();
  Object FLOAT();
  Object FLOAT4();
  Object FLOAT8();
  Object BIT();
  Object TIME();
  Object TIMESTAMP();
  Object DATETIME();
  Object BINARY();
  Object VARBINARY();
  Object BLOB();
  Object YEAR();
};

class LengthTwoDimensionContextProxy : public ContextProxy {
public:
  LengthTwoDimensionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object LR_BRACKET();
  Object COMMA();
  Object RR_BRACKET();
};

class LengthTwoOptionalDimensionContextProxy : public ContextProxy {
public:
  LengthTwoOptionalDimensionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
};

class StringDataTypeContextProxy : public ContextProxy {
public:
  StringDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lengthOneDimension();
  Object charSet();
  Object charsetName();
  Object collationName();
  Object CHAR();
  Object CHARACTER();
  Object VARCHAR();
  Object TINYTEXT();
  Object TEXT();
  Object MEDIUMTEXT();
  Object LONGTEXT();
  Object NCHAR();
  Object NVARCHAR();
  Object LONG();
  Object VARYING();
  Object BINARY();
  Object BINARYAt(size_t i);
  Object COLLATE();
};

class LongVarcharDataTypeContextProxy : public ContextProxy {
public:
  LongVarcharDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object charSet();
  Object charsetName();
  Object collationName();
  Object LONG();
  Object VARCHAR();
  Object BINARY();
  Object COLLATE();
};

class NationalStringDataTypeContextProxy : public ContextProxy {
public:
  NationalStringDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lengthOneDimension();
  Object NATIONAL();
  Object VARCHAR();
  Object CHARACTER();
  Object CHAR();
  Object BINARY();
  Object NCHAR();
};

class SimpleDataTypeContextProxy : public ContextProxy {
public:
  SimpleDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object DATE();
  Object TINYBLOB();
  Object MEDIUMBLOB();
  Object LONGBLOB();
  Object BOOL();
  Object BOOLEAN();
  Object SERIAL();
};

class ConvertedDataTypeContextProxy : public ContextProxy {
public:
  ConvertedDataTypeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object lengthOneDimension();
  Object charSet();
  Object charsetName();
  Object lengthTwoOptionalDimension();
  Object CHAR();
  Object SIGNED();
  Object UNSIGNED();
  Object ARRAY();
  Object BINARY();
  Object NCHAR();
  Object FLOAT();
  Object DATE();
  Object DATETIME();
  Object TIME();
  Object YEAR();
  Object JSON();
  Object INT();
  Object INTEGER();
  Object DOUBLE();
  Object DECIMAL();
  Object DEC();
};

class ExpressionOrDefaultContextProxy : public ContextProxy {
public:
  ExpressionOrDefaultContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object DEFAULT();
};

class UnaryOperatorContextProxy : public ContextProxy {
public:
  UnaryOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object EXCLAMATION_SYMBOL();
  Object BIT_NOT_OP();
  Object PLUS();
  Object MINUS();
  Object NOT();
};

class SpecificFunctionContextProxy : public ContextProxy {
public:
  SpecificFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class SpecificFunctionCallContextProxy : public ContextProxy {
public:
  SpecificFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object specificFunction();

};

class PasswordFunctionCallContextProxy : public ContextProxy {
public:
  PasswordFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object passwordFunctionClause();

};

class UdfFunctionCallContextProxy : public ContextProxy {
public:
  UdfFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullId();
  Object functionArgs();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class FunctionArgsContextProxy : public ContextProxy {
public:
  FunctionArgsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();
  Object constantAt(size_t i);
  Object fullColumnName();
  Object fullColumnNameAt(size_t i);
  Object functionCall();
  Object functionCallAt(size_t i);
  Object expression();
  Object expressionAt(size_t i);
  Object COMMA();
  Object COMMAAt(size_t i);
};

class NonAggregateWindowedFunctionContextProxy : public ContextProxy {
public:
  NonAggregateWindowedFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object overClause();
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object LAG();
  Object LEAD();
  Object COMMA();
  Object COMMAAt(size_t i);
  Object FIRST_VALUE();
  Object LAST_VALUE();
  Object CUME_DIST();
  Object DENSE_RANK();
  Object PERCENT_RANK();
  Object RANK();
  Object ROW_NUMBER();
  Object NTH_VALUE();
  Object NTILE();
};

class NonAggregateFunctionCallContextProxy : public ContextProxy {
public:
  NonAggregateFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object nonAggregateWindowedFunction();

};

class AggregateWindowedFunctionContextProxy : public ContextProxy {
public:
  AggregateWindowedFunctionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionArg();
  Object overClause();
  Object functionArgs();
  Object orderByExpression();
  Object orderByExpressionAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object AVG();
  Object MAX();
  Object MIN();
  Object SUM();
  Object ALL();
  Object DISTINCT();
  Object COUNT();
  Object STAR();
  Object BIT_AND();
  Object BIT_OR();
  Object BIT_XOR();
  Object STD();
  Object STDDEV();
  Object STDDEV_POP();
  Object STDDEV_SAMP();
  Object VAR_POP();
  Object VAR_SAMP();
  Object VARIANCE();
  Object GROUP_CONCAT();
  Object ORDER();
  Object BY();
  Object SEPARATOR();
  Object STRING_LITERAL();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class AggregateFunctionCallContextProxy : public ContextProxy {
public:
  AggregateFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object aggregateWindowedFunction();

};

class ScalarFunctionCallContextProxy : public ContextProxy {
public:
  ScalarFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object scalarFunctionName();
  Object functionArgs();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class PositionFunctionCallContextProxy : public ContextProxy {
public:
  PositionFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object stringLiteralAt(size_t i);
  Object expression();
  Object expressionAt(size_t i);
  Object POSITION();
  Object LR_BRACKET();
  Object IN();
  Object RR_BRACKET();
};

class TrimFunctionCallContextProxy : public ContextProxy {
public:
  TrimFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object stringLiteralAt(size_t i);
  Object expression();
  Object expressionAt(size_t i);
  Object TRIM();
  Object LR_BRACKET();
  Object FROM();
  Object RR_BRACKET();
  Object BOTH();
  Object LEADING();
  Object TRAILING();
};

class JsonValueFunctionCallContextProxy : public ContextProxy {
public:
  JsonValueFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object convertedDataType();
  Object jsonOnEmpty();
  Object jsonOnError();
  Object JSON_VALUE();
  Object LR_BRACKET();
  Object COMMA();
  Object RR_BRACKET();
  Object RETURNING();
};

class CaseFunctionCallContextProxy : public ContextProxy {
public:
  CaseFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object caseFuncAlternative();
  Object caseFuncAlternativeAt(size_t i);
  Object functionArg();
  Object CASE();
  Object END();
  Object ELSE();
};

class CaseFuncAlternativeContextProxy : public ContextProxy {
public:
  CaseFuncAlternativeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionArg();
  Object functionArgAt(size_t i);
  Object WHEN();
  Object THEN();
};

class FunctionArgContextProxy : public ContextProxy {
public:
  FunctionArgContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();
  Object fullColumnName();
  Object functionCall();
  Object expression();

};

class ExtractFunctionCallContextProxy : public ContextProxy {
public:
  ExtractFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object intervalType();
  Object stringLiteral();
  Object expression();
  Object EXTRACT();
  Object LR_BRACKET();
  Object FROM();
  Object RR_BRACKET();
};

class DataTypeFunctionCallContextProxy : public ContextProxy {
public:
  DataTypeFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object convertedDataType();
  Object charsetName();
  Object CONVERT();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object USING();
  Object CAST();
  Object AS();
};

class ValuesFunctionCallContextProxy : public ContextProxy {
public:
  ValuesFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();
  Object VALUES();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class CaseExpressionFunctionCallContextProxy : public ContextProxy {
public:
  CaseExpressionFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object caseFuncAlternative();
  Object caseFuncAlternativeAt(size_t i);
  Object functionArg();
  Object CASE();
  Object END();
  Object ELSE();
};

class CurrentUserContextProxy : public ContextProxy {
public:
  CurrentUserContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object currentUserExpression();

};

class SimpleFunctionCallContextProxy : public ContextProxy {
public:
  SimpleFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object CURRENT_DATE();
  Object CURRENT_TIME();
  Object CURRENT_TIMESTAMP();
  Object LOCALTIME();
  Object UTC_TIMESTAMP();
  Object SCHEMA();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class CharFunctionCallContextProxy : public ContextProxy {
public:
  CharFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionArgs();
  Object charsetName();
  Object CHAR();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object USING();
};

class WeightFunctionCallContextProxy : public ContextProxy {
public:
  WeightFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object expression();
  Object decimalLiteral();
  Object levelsInWeightString();
  Object WEIGHT_STRING();
  Object LR_BRACKET();
  Object LR_BRACKETAt(size_t i);
  Object RR_BRACKET();
  Object RR_BRACKETAt(size_t i);
  Object AS();
  Object CHAR();
  Object BINARY();
};

class LevelsInWeightStringContextProxy : public ContextProxy {
public:
  LevelsInWeightStringContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class GetFormatFunctionCallContextProxy : public ContextProxy {
public:
  GetFormatFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object GET_FORMAT();
  Object LR_BRACKET();
  Object COMMA();
  Object RR_BRACKET();
  Object DATE();
  Object TIME();
  Object DATETIME();
};

class SubstrFunctionCallContextProxy : public ContextProxy {
public:
  SubstrFunctionCallContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object stringLiteral();
  Object expression();
  Object expressionAt(size_t i);
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object LR_BRACKET();
  Object FROM();
  Object RR_BRACKET();
  Object SUBSTR();
  Object SUBSTRING();
  Object FOR();
};

class LevelWeightRangeContextProxy : public ContextProxy {
public:
  LevelWeightRangeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object decimalLiteralAt(size_t i);
  Object LEVEL();
  Object MINUS();
};

class LevelWeightListContextProxy : public ContextProxy {
public:
  LevelWeightListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object levelInWeightListElement();
  Object levelInWeightListElementAt(size_t i);
  Object LEVEL();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class LevelInWeightListElementContextProxy : public ContextProxy {
public:
  LevelInWeightListElementContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object decimalLiteral();
  Object ASC();
  Object DESC();
  Object REVERSE();
};

class OverClauseContextProxy : public ContextProxy {
public:
  OverClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object windowSpec();
  Object windowName();
  Object OVER();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class PartitionClauseContextProxy : public ContextProxy {
public:
  PartitionClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object PARTITION();
  Object BY();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class FrameClauseContextProxy : public ContextProxy {
public:
  FrameClauseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object frameUnits();
  Object frameExtent();

};

class FrameUnitsContextProxy : public ContextProxy {
public:
  FrameUnitsContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ROWS();
  Object RANGE();
};

class FrameExtentContextProxy : public ContextProxy {
public:
  FrameExtentContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object frameRange();
  Object frameBetween();

};

class FrameRangeContextProxy : public ContextProxy {
public:
  FrameRangeContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object CURRENT();
  Object ROW();
  Object UNBOUNDED();
  Object PRECEDING();
  Object FOLLOWING();
};

class FrameBetweenContextProxy : public ContextProxy {
public:
  FrameBetweenContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object frameRange();
  Object frameRangeAt(size_t i);
  Object BETWEEN();
  Object AND();
};

class FunctionNameBaseContextProxy : public ContextProxy {
public:
  FunctionNameBaseContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object ABS();
  Object ACOS();
  Object ADDDATE();
  Object ADDTIME();
  Object AES_DECRYPT();
  Object AES_ENCRYPT();
  Object AREA();
  Object ASBINARY();
  Object ASIN();
  Object ASTEXT();
  Object ASWKB();
  Object ASWKT();
  Object ASYMMETRIC_DECRYPT();
  Object ASYMMETRIC_DERIVE();
  Object ASYMMETRIC_ENCRYPT();
  Object ASYMMETRIC_SIGN();
  Object ASYMMETRIC_VERIFY();
  Object ATAN();
  Object ATAN2();
  Object BENCHMARK();
  Object BIN();
  Object BIT_COUNT();
  Object BIT_LENGTH();
  Object BUFFER();
  Object CEIL();
  Object CEILING();
  Object CENTROID();
  Object CHARACTER_LENGTH();
  Object CHARSET();
  Object CHAR_LENGTH();
  Object COERCIBILITY();
  Object COLLATION();
  Object COMPRESS();
  Object CONCAT();
  Object CONCAT_WS();
  Object CONNECTION_ID();
  Object CONV();
  Object CONVERT_TZ();
  Object COS();
  Object COT();
  Object COUNT();
  Object CRC32();
  Object CREATE_ASYMMETRIC_PRIV_KEY();
  Object CREATE_ASYMMETRIC_PUB_KEY();
  Object CREATE_DH_PARAMETERS();
  Object CREATE_DIGEST();
  Object CROSSES();
  Object CUME_DIST();
  Object DATABASE();
  Object DATE();
  Object DATEDIFF();
  Object DATE_FORMAT();
  Object DAY();
  Object DAYNAME();
  Object DAYOFMONTH();
  Object DAYOFWEEK();
  Object DAYOFYEAR();
  Object DECODE();
  Object DEGREES();
  Object DENSE_RANK();
  Object DES_DECRYPT();
  Object DES_ENCRYPT();
  Object DIMENSION();
  Object DISJOINT();
  Object ELT();
  Object ENCODE();
  Object ENCRYPT();
  Object ENDPOINT();
  Object ENVELOPE();
  Object EQUALS();
  Object EXP();
  Object EXPORT_SET();
  Object EXTERIORRING();
  Object EXTRACTVALUE();
  Object FIELD();
  Object FIND_IN_SET();
  Object FIRST_VALUE();
  Object FLOOR();
  Object FORMAT();
  Object FOUND_ROWS();
  Object FROM_BASE64();
  Object FROM_DAYS();
  Object FROM_UNIXTIME();
  Object GEOMCOLLFROMTEXT();
  Object GEOMCOLLFROMWKB();
  Object GEOMETRYCOLLECTION();
  Object GEOMETRYCOLLECTIONFROMTEXT();
  Object GEOMETRYCOLLECTIONFROMWKB();
  Object GEOMETRYFROMTEXT();
  Object GEOMETRYFROMWKB();
  Object GEOMETRYN();
  Object GEOMETRYTYPE();
  Object GEOMFROMTEXT();
  Object GEOMFROMWKB();
  Object GET_FORMAT();
  Object GET_LOCK();
  Object GLENGTH();
  Object GREATEST();
  Object GTID_SUBSET();
  Object GTID_SUBTRACT();
  Object HEX();
  Object HOUR();
  Object IFNULL();
  Object INET6_ATON();
  Object INET6_NTOA();
  Object INET_ATON();
  Object INET_NTOA();
  Object INSTR();
  Object INTERIORRINGN();
  Object INTERSECTS();
  Object INVISIBLE();
  Object ISCLOSED();
  Object ISEMPTY();
  Object ISNULL();
  Object ISSIMPLE();
  Object IS_FREE_LOCK();
  Object IS_IPV4();
  Object IS_IPV4_COMPAT();
  Object IS_IPV4_MAPPED();
  Object IS_IPV6();
  Object IS_USED_LOCK();
  Object LAG();
  Object LAST_INSERT_ID();
  Object LAST_VALUE();
  Object LCASE();
  Object LEAD();
  Object LEAST();
  Object LEFT();
  Object LENGTH();
  Object LINEFROMTEXT();
  Object LINEFROMWKB();
  Object LINESTRING();
  Object LINESTRINGFROMTEXT();
  Object LINESTRINGFROMWKB();
  Object LN();
  Object LOAD_FILE();
  Object LOCATE();
  Object LOG();
  Object LOG10();
  Object LOG2();
  Object LOWER();
  Object LPAD();
  Object LTRIM();
  Object MAKEDATE();
  Object MAKETIME();
  Object MAKE_SET();
  Object MASTER_POS_WAIT();
  Object MBRCONTAINS();
  Object MBRDISJOINT();
  Object MBREQUAL();
  Object MBRINTERSECTS();
  Object MBROVERLAPS();
  Object MBRTOUCHES();
  Object MBRWITHIN();
  Object MD5();
  Object MICROSECOND();
  Object MINUTE();
  Object MLINEFROMTEXT();
  Object MLINEFROMWKB();
  Object MOD();
  Object MONTH();
  Object MONTHNAME();
  Object MPOINTFROMTEXT();
  Object MPOINTFROMWKB();
  Object MPOLYFROMTEXT();
  Object MPOLYFROMWKB();
  Object MULTILINESTRING();
  Object MULTILINESTRINGFROMTEXT();
  Object MULTILINESTRINGFROMWKB();
  Object MULTIPOINT();
  Object MULTIPOINTFROMTEXT();
  Object MULTIPOINTFROMWKB();
  Object MULTIPOLYGON();
  Object MULTIPOLYGONFROMTEXT();
  Object MULTIPOLYGONFROMWKB();
  Object NAME_CONST();
  Object NTH_VALUE();
  Object NTILE();
  Object NULLIF();
  Object NUMGEOMETRIES();
  Object NUMINTERIORRINGS();
  Object NUMPOINTS();
  Object OCT();
  Object OCTET_LENGTH();
  Object ORD();
  Object OVERLAPS();
  Object PERCENT_RANK();
  Object PERIOD_ADD();
  Object PERIOD_DIFF();
  Object PI();
  Object POINT();
  Object POINTFROMTEXT();
  Object POINTFROMWKB();
  Object POINTN();
  Object POLYFROMTEXT();
  Object POLYFROMWKB();
  Object POLYGON();
  Object POLYGONFROMTEXT();
  Object POLYGONFROMWKB();
  Object POSITION();
  Object POW();
  Object POWER();
  Object QUARTER();
  Object QUOTE();
  Object RADIANS();
  Object RAND();
  Object RANDOM();
  Object RANK();
  Object RANDOM_BYTES();
  Object RELEASE_LOCK();
  Object REVERSE();
  Object RIGHT();
  Object ROUND();
  Object ROW_COUNT();
  Object ROW_NUMBER();
  Object RPAD();
  Object RTRIM();
  Object SCHEMA();
  Object SECOND();
  Object SEC_TO_TIME();
  Object SESSION_USER();
  Object SESSION_VARIABLES_ADMIN();
  Object SHA();
  Object SHA1();
  Object SHA2();
  Object SIGN();
  Object SIN();
  Object SLEEP();
  Object SOUNDEX();
  Object SQL_THREAD_WAIT_AFTER_GTIDS();
  Object SQRT();
  Object SRID();
  Object STARTPOINT();
  Object STRCMP();
  Object STR_TO_DATE();
  Object ST_AREA();
  Object ST_ASBINARY();
  Object ST_ASTEXT();
  Object ST_ASWKB();
  Object ST_ASWKT();
  Object ST_BUFFER();
  Object ST_CENTROID();
  Object ST_CONTAINS();
  Object ST_CROSSES();
  Object ST_DIFFERENCE();
  Object ST_DIMENSION();
  Object ST_DISJOINT();
  Object ST_DISTANCE();
  Object ST_ENDPOINT();
  Object ST_ENVELOPE();
  Object ST_EQUALS();
  Object ST_EXTERIORRING();
  Object ST_GEOMCOLLFROMTEXT();
  Object ST_GEOMCOLLFROMTXT();
  Object ST_GEOMCOLLFROMWKB();
  Object ST_GEOMETRYCOLLECTIONFROMTEXT();
  Object ST_GEOMETRYCOLLECTIONFROMWKB();
  Object ST_GEOMETRYFROMTEXT();
  Object ST_GEOMETRYFROMWKB();
  Object ST_GEOMETRYN();
  Object ST_GEOMETRYTYPE();
  Object ST_GEOMFROMTEXT();
  Object ST_GEOMFROMWKB();
  Object ST_INTERIORRINGN();
  Object ST_INTERSECTION();
  Object ST_INTERSECTS();
  Object ST_ISCLOSED();
  Object ST_ISEMPTY();
  Object ST_ISSIMPLE();
  Object ST_LINEFROMTEXT();
  Object ST_LINEFROMWKB();
  Object ST_LINESTRINGFROMTEXT();
  Object ST_LINESTRINGFROMWKB();
  Object ST_NUMGEOMETRIES();
  Object ST_NUMINTERIORRING();
  Object ST_NUMINTERIORRINGS();
  Object ST_NUMPOINTS();
  Object ST_OVERLAPS();
  Object ST_POINTFROMTEXT();
  Object ST_POINTFROMWKB();
  Object ST_POINTN();
  Object ST_POLYFROMTEXT();
  Object ST_POLYFROMWKB();
  Object ST_POLYGONFROMTEXT();
  Object ST_POLYGONFROMWKB();
  Object ST_SRID();
  Object ST_STARTPOINT();
  Object ST_SYMDIFFERENCE();
  Object ST_TOUCHES();
  Object ST_UNION();
  Object ST_WITHIN();
  Object ST_X();
  Object ST_Y();
  Object SUBDATE();
  Object SUBSTRING_INDEX();
  Object SUBTIME();
  Object SYSTEM_USER();
  Object TAN();
  Object TIME();
  Object TIMEDIFF();
  Object TIMESTAMP();
  Object TIMESTAMPADD();
  Object TIMESTAMPDIFF();
  Object TIME_FORMAT();
  Object TIME_TO_SEC();
  Object TOUCHES();
  Object TO_BASE64();
  Object TO_DAYS();
  Object TO_SECONDS();
  Object UCASE();
  Object UNCOMPRESS();
  Object UNCOMPRESSED_LENGTH();
  Object UNHEX();
  Object UNIX_TIMESTAMP();
  Object UPDATEXML();
  Object UPPER();
  Object UUID();
  Object UUID_SHORT();
  Object VALIDATE_PASSWORD_STRENGTH();
  Object VERSION();
  Object VISIBLE();
  Object WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS();
  Object WEEK();
  Object WEEKDAY();
  Object WEEKOFYEAR();
  Object WEIGHT_STRING();
  Object WITHIN();
  Object YEAR();
  Object YEARWEEK();
  Object Y_FUNCTION();
  Object X_FUNCTION();
  Object JSON_ARRAY();
  Object JSON_OBJECT();
  Object JSON_QUOTE();
  Object JSON_CONTAINS();
  Object JSON_CONTAINS_PATH();
  Object JSON_EXTRACT();
  Object JSON_KEYS();
  Object JSON_OVERLAPS();
  Object JSON_SEARCH();
  Object JSON_VALUE();
  Object JSON_ARRAY_APPEND();
  Object JSON_ARRAY_INSERT();
  Object JSON_INSERT();
  Object JSON_MERGE();
  Object JSON_MERGE_PATCH();
  Object JSON_MERGE_PRESERVE();
  Object JSON_REMOVE();
  Object JSON_REPLACE();
  Object JSON_SET();
  Object JSON_UNQUOTE();
  Object JSON_DEPTH();
  Object JSON_LENGTH();
  Object JSON_TYPE();
  Object JSON_VALID();
  Object JSON_TABLE();
  Object JSON_SCHEMA_VALID();
  Object JSON_SCHEMA_VALIDATION_REPORT();
  Object JSON_PRETTY();
  Object JSON_STORAGE_FREE();
  Object JSON_STORAGE_SIZE();
  Object JSON_ARRAYAGG();
  Object JSON_OBJECTAGG();
};

class PredicateContextProxy : public ContextProxy {
public:
  PredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class IsExpressionContextProxy : public ContextProxy {
public:
  IsExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object IS();
  Object TRUE();
  Object FALSE();
  Object UNKNOWN();
  Object NOT();
};

class NotExpressionContextProxy : public ContextProxy {
public:
  NotExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object NOT();
  Object EXCLAMATION_SYMBOL();
};

class LogicalExpressionContextProxy : public ContextProxy {
public:
  LogicalExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object logicalOperator();

};

class LogicalOperatorContextProxy : public ContextProxy {
public:
  LogicalOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object AND();
  Object BIT_AND_OP();
  Object BIT_AND_OPAt(size_t i);
  Object XOR();
  Object OR();
  Object BIT_OR_OP();
  Object BIT_OR_OPAt(size_t i);
};

class PredicateExpressionContextProxy : public ContextProxy {
public:
  PredicateExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();

};

class SoundsLikePredicateContextProxy : public ContextProxy {
public:
  SoundsLikePredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object predicateAt(size_t i);
  Object SOUNDS();
  Object LIKE();
};

class ExpressionAtomContextProxy : public ContextProxy {
public:
  ExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};


};

class ExpressionAtomPredicateContextProxy : public ContextProxy {
public:
  ExpressionAtomPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionAtom();

};

class SubqueryComparisonPredicateContextProxy : public ContextProxy {
public:
  SubqueryComparisonPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object comparisonOperator();
  Object selectStatement();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object ALL();
  Object ANY();
  Object SOME();
};

class JsonMemberOfPredicateContextProxy : public ContextProxy {
public:
  JsonMemberOfPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object predicateAt(size_t i);
  Object MEMBER();
  Object OF();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class BinaryComparisonPredicateContextProxy : public ContextProxy {
public:
  BinaryComparisonPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object comparisonOperator();
  Object predicate();
  Object predicateAt(size_t i);

};

class InPredicateContextProxy : public ContextProxy {
public:
  InPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object selectStatement();
  Object expressions();
  Object IN();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object NOT();
};

class BetweenPredicateContextProxy : public ContextProxy {
public:
  BetweenPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object predicateAt(size_t i);
  Object BETWEEN();
  Object AND();
  Object NOT();
};

class IsNullPredicateContextProxy : public ContextProxy {
public:
  IsNullPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object nullNotnull();
  Object IS();
};

class LikePredicateContextProxy : public ContextProxy {
public:
  LikePredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object predicateAt(size_t i);
  Object LIKE();
  Object NOT();
  Object ESCAPE();
  Object STRING_LITERAL();
};

class RegexpPredicateContextProxy : public ContextProxy {
public:
  RegexpPredicateContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object predicate();
  Object predicateAt(size_t i);
  Object REGEXP();
  Object RLIKE();
  Object NOT();
};

class UnaryExpressionAtomContextProxy : public ContextProxy {
public:
  UnaryExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object unaryOperator();
  Object expressionAtom();

};

class CollateExpressionAtomContextProxy : public ContextProxy {
public:
  CollateExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionAtom();
  Object collationName();
  Object COLLATE();
};

class VariableAssignExpressionAtomContextProxy : public ContextProxy {
public:
  VariableAssignExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionAtom();
  Object LOCAL_ID();
  Object VAR_ASSIGN();
};

class MysqlVariableExpressionAtomContextProxy : public ContextProxy {
public:
  MysqlVariableExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object mysqlVariable();

};

class NestedExpressionAtomContextProxy : public ContextProxy {
public:
  NestedExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class NestedRowExpressionAtomContextProxy : public ContextProxy {
public:
  NestedRowExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object expressionAt(size_t i);
  Object ROW();
  Object LR_BRACKET();
  Object RR_BRACKET();
  Object COMMA();
  Object COMMAAt(size_t i);
};

class MultOperatorContextProxy : public ContextProxy {
public:
  MultOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object STAR();
  Object DIVIDE();
  Object MODULE();
  Object DIV();
  Object MOD();
};

class MathExpressionAtomContextProxy : public ContextProxy {
public:
  MathExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object multOperator();
  Object expressionAtom();
  Object expressionAtomAt(size_t i);
  Object addOperator();

};

class AddOperatorContextProxy : public ContextProxy {
public:
  AddOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object PLUS();
  Object MINUS();
};

class ExistsExpressionAtomContextProxy : public ContextProxy {
public:
  ExistsExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectStatement();
  Object EXISTS();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class IntervalExpressionAtomContextProxy : public ContextProxy {
public:
  IntervalExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expression();
  Object intervalType();
  Object INTERVAL();
};

class JsonOperatorContextProxy : public ContextProxy {
public:
  JsonOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object MINUS();
  Object GREATER_SYMBOL();
  Object GREATER_SYMBOLAt(size_t i);
};

class JsonExpressionAtomContextProxy : public ContextProxy {
public:
  JsonExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object jsonOperator();
  Object expressionAtom();
  Object expressionAtomAt(size_t i);

};

class SubqueryExpressionAtomContextProxy : public ContextProxy {
public:
  SubqueryExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object selectStatement();
  Object LR_BRACKET();
  Object RR_BRACKET();
};

class ConstantExpressionAtomContextProxy : public ContextProxy {
public:
  ConstantExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object constant();

};

class FunctionCallExpressionAtomContextProxy : public ContextProxy {
public:
  FunctionCallExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object functionCall();

};

class BinaryExpressionAtomContextProxy : public ContextProxy {
public:
  BinaryExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object expressionAtom();
  Object BINARY();
};

class FullColumnNameExpressionAtomContextProxy : public ContextProxy {
public:
  FullColumnNameExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object fullColumnName();

};

class BitOperatorContextProxy : public ContextProxy {
public:
  BitOperatorContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};

  Object LESS_SYMBOL();
  Object LESS_SYMBOLAt(size_t i);
  Object GREATER_SYMBOL();
  Object GREATER_SYMBOLAt(size_t i);
  Object BIT_AND_OP();
  Object BIT_XOR_OP();
  Object BIT_OR_OP();
};

class BitExpressionAtomContextProxy : public ContextProxy {
public:
  BitExpressionAtomContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
  Object bitOperator();
  Object expressionAtom();
  Object expressionAtomAt(size_t i);

};


namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RootContext*> {
  public:
    VALUE convert(MySqlParser::RootContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RootContext>(x, false, rb_cRootContext);
    }
  };

  template <>
  class To_Ruby<RootContextProxy*> {
  public:
    VALUE convert(RootContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RootContextProxy>(x, false, rb_cRootContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SqlStatementsContext*> {
  public:
    VALUE convert(MySqlParser::SqlStatementsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SqlStatementsContext>(x, false, rb_cSqlStatementsContext);
    }
  };

  template <>
  class To_Ruby<SqlStatementsContextProxy*> {
  public:
    VALUE convert(SqlStatementsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SqlStatementsContextProxy>(x, false, rb_cSqlStatementsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SqlStatementContext*> {
  public:
    VALUE convert(MySqlParser::SqlStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SqlStatementContext>(x, false, rb_cSqlStatementContext);
    }
  };

  template <>
  class To_Ruby<SqlStatementContextProxy*> {
  public:
    VALUE convert(SqlStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SqlStatementContextProxy>(x, false, rb_cSqlStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::EmptyStatement_Context*> {
  public:
    VALUE convert(MySqlParser::EmptyStatement_Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::EmptyStatement_Context>(x, false, rb_cEmptyStatement_Context);
    }
  };

  template <>
  class To_Ruby<EmptyStatement_ContextProxy*> {
  public:
    VALUE convert(EmptyStatement_ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<EmptyStatement_ContextProxy>(x, false, rb_cEmptyStatement_Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DdlStatementContext*> {
  public:
    VALUE convert(MySqlParser::DdlStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DdlStatementContext>(x, false, rb_cDdlStatementContext);
    }
  };

  template <>
  class To_Ruby<DdlStatementContextProxy*> {
  public:
    VALUE convert(DdlStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DdlStatementContextProxy>(x, false, rb_cDdlStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DmlStatementContext*> {
  public:
    VALUE convert(MySqlParser::DmlStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DmlStatementContext>(x, false, rb_cDmlStatementContext);
    }
  };

  template <>
  class To_Ruby<DmlStatementContextProxy*> {
  public:
    VALUE convert(DmlStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DmlStatementContextProxy>(x, false, rb_cDmlStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TransactionStatementContext*> {
  public:
    VALUE convert(MySqlParser::TransactionStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TransactionStatementContext>(x, false, rb_cTransactionStatementContext);
    }
  };

  template <>
  class To_Ruby<TransactionStatementContextProxy*> {
  public:
    VALUE convert(TransactionStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TransactionStatementContextProxy>(x, false, rb_cTransactionStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReplicationStatementContext*> {
  public:
    VALUE convert(MySqlParser::ReplicationStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReplicationStatementContext>(x, false, rb_cReplicationStatementContext);
    }
  };

  template <>
  class To_Ruby<ReplicationStatementContextProxy*> {
  public:
    VALUE convert(ReplicationStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReplicationStatementContextProxy>(x, false, rb_cReplicationStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PreparedStatementContext*> {
  public:
    VALUE convert(MySqlParser::PreparedStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PreparedStatementContext>(x, false, rb_cPreparedStatementContext);
    }
  };

  template <>
  class To_Ruby<PreparedStatementContextProxy*> {
  public:
    VALUE convert(PreparedStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PreparedStatementContextProxy>(x, false, rb_cPreparedStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AdministrationStatementContext*> {
  public:
    VALUE convert(MySqlParser::AdministrationStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AdministrationStatementContext>(x, false, rb_cAdministrationStatementContext);
    }
  };

  template <>
  class To_Ruby<AdministrationStatementContextProxy*> {
  public:
    VALUE convert(AdministrationStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AdministrationStatementContextProxy>(x, false, rb_cAdministrationStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UtilityStatementContext*> {
  public:
    VALUE convert(MySqlParser::UtilityStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UtilityStatementContext>(x, false, rb_cUtilityStatementContext);
    }
  };

  template <>
  class To_Ruby<UtilityStatementContextProxy*> {
  public:
    VALUE convert(UtilityStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UtilityStatementContextProxy>(x, false, rb_cUtilityStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateDatabaseContext*> {
  public:
    VALUE convert(MySqlParser::CreateDatabaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateDatabaseContext>(x, false, rb_cCreateDatabaseContext);
    }
  };

  template <>
  class To_Ruby<CreateDatabaseContextProxy*> {
  public:
    VALUE convert(CreateDatabaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateDatabaseContextProxy>(x, false, rb_cCreateDatabaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateEventContext*> {
  public:
    VALUE convert(MySqlParser::CreateEventContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateEventContext>(x, false, rb_cCreateEventContext);
    }
  };

  template <>
  class To_Ruby<CreateEventContextProxy*> {
  public:
    VALUE convert(CreateEventContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateEventContextProxy>(x, false, rb_cCreateEventContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateIndexContext*> {
  public:
    VALUE convert(MySqlParser::CreateIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateIndexContext>(x, false, rb_cCreateIndexContext);
    }
  };

  template <>
  class To_Ruby<CreateIndexContextProxy*> {
  public:
    VALUE convert(CreateIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateIndexContextProxy>(x, false, rb_cCreateIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateLogfileGroupContext*> {
  public:
    VALUE convert(MySqlParser::CreateLogfileGroupContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateLogfileGroupContext>(x, false, rb_cCreateLogfileGroupContext);
    }
  };

  template <>
  class To_Ruby<CreateLogfileGroupContextProxy*> {
  public:
    VALUE convert(CreateLogfileGroupContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateLogfileGroupContextProxy>(x, false, rb_cCreateLogfileGroupContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateProcedureContext*> {
  public:
    VALUE convert(MySqlParser::CreateProcedureContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateProcedureContext>(x, false, rb_cCreateProcedureContext);
    }
  };

  template <>
  class To_Ruby<CreateProcedureContextProxy*> {
  public:
    VALUE convert(CreateProcedureContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateProcedureContextProxy>(x, false, rb_cCreateProcedureContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateFunctionContext*> {
  public:
    VALUE convert(MySqlParser::CreateFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateFunctionContext>(x, false, rb_cCreateFunctionContext);
    }
  };

  template <>
  class To_Ruby<CreateFunctionContextProxy*> {
  public:
    VALUE convert(CreateFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateFunctionContextProxy>(x, false, rb_cCreateFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateServerContext*> {
  public:
    VALUE convert(MySqlParser::CreateServerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateServerContext>(x, false, rb_cCreateServerContext);
    }
  };

  template <>
  class To_Ruby<CreateServerContextProxy*> {
  public:
    VALUE convert(CreateServerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateServerContextProxy>(x, false, rb_cCreateServerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateTableContext*> {
  public:
    VALUE convert(MySqlParser::CreateTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateTableContext>(x, false, rb_cCreateTableContext);
    }
  };

  template <>
  class To_Ruby<CreateTableContextProxy*> {
  public:
    VALUE convert(CreateTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateTableContextProxy>(x, false, rb_cCreateTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateTablespaceInnodbContext*> {
  public:
    VALUE convert(MySqlParser::CreateTablespaceInnodbContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateTablespaceInnodbContext>(x, false, rb_cCreateTablespaceInnodbContext);
    }
  };

  template <>
  class To_Ruby<CreateTablespaceInnodbContextProxy*> {
  public:
    VALUE convert(CreateTablespaceInnodbContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateTablespaceInnodbContextProxy>(x, false, rb_cCreateTablespaceInnodbContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateTablespaceNdbContext*> {
  public:
    VALUE convert(MySqlParser::CreateTablespaceNdbContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateTablespaceNdbContext>(x, false, rb_cCreateTablespaceNdbContext);
    }
  };

  template <>
  class To_Ruby<CreateTablespaceNdbContextProxy*> {
  public:
    VALUE convert(CreateTablespaceNdbContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateTablespaceNdbContextProxy>(x, false, rb_cCreateTablespaceNdbContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateTriggerContext*> {
  public:
    VALUE convert(MySqlParser::CreateTriggerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateTriggerContext>(x, false, rb_cCreateTriggerContext);
    }
  };

  template <>
  class To_Ruby<CreateTriggerContextProxy*> {
  public:
    VALUE convert(CreateTriggerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateTriggerContextProxy>(x, false, rb_cCreateTriggerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateViewContext*> {
  public:
    VALUE convert(MySqlParser::CreateViewContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateViewContext>(x, false, rb_cCreateViewContext);
    }
  };

  template <>
  class To_Ruby<CreateViewContextProxy*> {
  public:
    VALUE convert(CreateViewContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateViewContextProxy>(x, false, rb_cCreateViewContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateRoleContext*> {
  public:
    VALUE convert(MySqlParser::CreateRoleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateRoleContext>(x, false, rb_cCreateRoleContext);
    }
  };

  template <>
  class To_Ruby<CreateRoleContextProxy*> {
  public:
    VALUE convert(CreateRoleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateRoleContextProxy>(x, false, rb_cCreateRoleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterDatabaseContext*> {
  public:
    VALUE convert(MySqlParser::AlterDatabaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterDatabaseContext>(x, false, rb_cAlterDatabaseContext);
    }
  };

  template <>
  class To_Ruby<AlterDatabaseContextProxy*> {
  public:
    VALUE convert(AlterDatabaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterDatabaseContextProxy>(x, false, rb_cAlterDatabaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterEventContext*> {
  public:
    VALUE convert(MySqlParser::AlterEventContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterEventContext>(x, false, rb_cAlterEventContext);
    }
  };

  template <>
  class To_Ruby<AlterEventContextProxy*> {
  public:
    VALUE convert(AlterEventContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterEventContextProxy>(x, false, rb_cAlterEventContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterFunctionContext*> {
  public:
    VALUE convert(MySqlParser::AlterFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterFunctionContext>(x, false, rb_cAlterFunctionContext);
    }
  };

  template <>
  class To_Ruby<AlterFunctionContextProxy*> {
  public:
    VALUE convert(AlterFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterFunctionContextProxy>(x, false, rb_cAlterFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterInstanceContext*> {
  public:
    VALUE convert(MySqlParser::AlterInstanceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterInstanceContext>(x, false, rb_cAlterInstanceContext);
    }
  };

  template <>
  class To_Ruby<AlterInstanceContextProxy*> {
  public:
    VALUE convert(AlterInstanceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterInstanceContextProxy>(x, false, rb_cAlterInstanceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterLogfileGroupContext*> {
  public:
    VALUE convert(MySqlParser::AlterLogfileGroupContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterLogfileGroupContext>(x, false, rb_cAlterLogfileGroupContext);
    }
  };

  template <>
  class To_Ruby<AlterLogfileGroupContextProxy*> {
  public:
    VALUE convert(AlterLogfileGroupContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterLogfileGroupContextProxy>(x, false, rb_cAlterLogfileGroupContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterProcedureContext*> {
  public:
    VALUE convert(MySqlParser::AlterProcedureContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterProcedureContext>(x, false, rb_cAlterProcedureContext);
    }
  };

  template <>
  class To_Ruby<AlterProcedureContextProxy*> {
  public:
    VALUE convert(AlterProcedureContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterProcedureContextProxy>(x, false, rb_cAlterProcedureContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterServerContext*> {
  public:
    VALUE convert(MySqlParser::AlterServerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterServerContext>(x, false, rb_cAlterServerContext);
    }
  };

  template <>
  class To_Ruby<AlterServerContextProxy*> {
  public:
    VALUE convert(AlterServerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterServerContextProxy>(x, false, rb_cAlterServerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterTableContext*> {
  public:
    VALUE convert(MySqlParser::AlterTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterTableContext>(x, false, rb_cAlterTableContext);
    }
  };

  template <>
  class To_Ruby<AlterTableContextProxy*> {
  public:
    VALUE convert(AlterTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterTableContextProxy>(x, false, rb_cAlterTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::AlterTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterTablespaceContext>(x, false, rb_cAlterTablespaceContext);
    }
  };

  template <>
  class To_Ruby<AlterTablespaceContextProxy*> {
  public:
    VALUE convert(AlterTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterTablespaceContextProxy>(x, false, rb_cAlterTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterViewContext*> {
  public:
    VALUE convert(MySqlParser::AlterViewContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterViewContext>(x, false, rb_cAlterViewContext);
    }
  };

  template <>
  class To_Ruby<AlterViewContextProxy*> {
  public:
    VALUE convert(AlterViewContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterViewContextProxy>(x, false, rb_cAlterViewContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropDatabaseContext*> {
  public:
    VALUE convert(MySqlParser::DropDatabaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropDatabaseContext>(x, false, rb_cDropDatabaseContext);
    }
  };

  template <>
  class To_Ruby<DropDatabaseContextProxy*> {
  public:
    VALUE convert(DropDatabaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropDatabaseContextProxy>(x, false, rb_cDropDatabaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropEventContext*> {
  public:
    VALUE convert(MySqlParser::DropEventContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropEventContext>(x, false, rb_cDropEventContext);
    }
  };

  template <>
  class To_Ruby<DropEventContextProxy*> {
  public:
    VALUE convert(DropEventContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropEventContextProxy>(x, false, rb_cDropEventContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropIndexContext*> {
  public:
    VALUE convert(MySqlParser::DropIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropIndexContext>(x, false, rb_cDropIndexContext);
    }
  };

  template <>
  class To_Ruby<DropIndexContextProxy*> {
  public:
    VALUE convert(DropIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropIndexContextProxy>(x, false, rb_cDropIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropLogfileGroupContext*> {
  public:
    VALUE convert(MySqlParser::DropLogfileGroupContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropLogfileGroupContext>(x, false, rb_cDropLogfileGroupContext);
    }
  };

  template <>
  class To_Ruby<DropLogfileGroupContextProxy*> {
  public:
    VALUE convert(DropLogfileGroupContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropLogfileGroupContextProxy>(x, false, rb_cDropLogfileGroupContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropProcedureContext*> {
  public:
    VALUE convert(MySqlParser::DropProcedureContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropProcedureContext>(x, false, rb_cDropProcedureContext);
    }
  };

  template <>
  class To_Ruby<DropProcedureContextProxy*> {
  public:
    VALUE convert(DropProcedureContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropProcedureContextProxy>(x, false, rb_cDropProcedureContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropFunctionContext*> {
  public:
    VALUE convert(MySqlParser::DropFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropFunctionContext>(x, false, rb_cDropFunctionContext);
    }
  };

  template <>
  class To_Ruby<DropFunctionContextProxy*> {
  public:
    VALUE convert(DropFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropFunctionContextProxy>(x, false, rb_cDropFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropServerContext*> {
  public:
    VALUE convert(MySqlParser::DropServerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropServerContext>(x, false, rb_cDropServerContext);
    }
  };

  template <>
  class To_Ruby<DropServerContextProxy*> {
  public:
    VALUE convert(DropServerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropServerContextProxy>(x, false, rb_cDropServerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropTableContext*> {
  public:
    VALUE convert(MySqlParser::DropTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropTableContext>(x, false, rb_cDropTableContext);
    }
  };

  template <>
  class To_Ruby<DropTableContextProxy*> {
  public:
    VALUE convert(DropTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropTableContextProxy>(x, false, rb_cDropTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::DropTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropTablespaceContext>(x, false, rb_cDropTablespaceContext);
    }
  };

  template <>
  class To_Ruby<DropTablespaceContextProxy*> {
  public:
    VALUE convert(DropTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropTablespaceContextProxy>(x, false, rb_cDropTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropTriggerContext*> {
  public:
    VALUE convert(MySqlParser::DropTriggerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropTriggerContext>(x, false, rb_cDropTriggerContext);
    }
  };

  template <>
  class To_Ruby<DropTriggerContextProxy*> {
  public:
    VALUE convert(DropTriggerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropTriggerContextProxy>(x, false, rb_cDropTriggerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropViewContext*> {
  public:
    VALUE convert(MySqlParser::DropViewContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropViewContext>(x, false, rb_cDropViewContext);
    }
  };

  template <>
  class To_Ruby<DropViewContextProxy*> {
  public:
    VALUE convert(DropViewContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropViewContextProxy>(x, false, rb_cDropViewContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropRoleContext*> {
  public:
    VALUE convert(MySqlParser::DropRoleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropRoleContext>(x, false, rb_cDropRoleContext);
    }
  };

  template <>
  class To_Ruby<DropRoleContextProxy*> {
  public:
    VALUE convert(DropRoleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropRoleContextProxy>(x, false, rb_cDropRoleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetRoleContext*> {
  public:
    VALUE convert(MySqlParser::SetRoleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetRoleContext>(x, false, rb_cSetRoleContext);
    }
  };

  template <>
  class To_Ruby<SetRoleContextProxy*> {
  public:
    VALUE convert(SetRoleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetRoleContextProxy>(x, false, rb_cSetRoleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RenameTableContext*> {
  public:
    VALUE convert(MySqlParser::RenameTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RenameTableContext>(x, false, rb_cRenameTableContext);
    }
  };

  template <>
  class To_Ruby<RenameTableContextProxy*> {
  public:
    VALUE convert(RenameTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RenameTableContextProxy>(x, false, rb_cRenameTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TruncateTableContext*> {
  public:
    VALUE convert(MySqlParser::TruncateTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TruncateTableContext>(x, false, rb_cTruncateTableContext);
    }
  };

  template <>
  class To_Ruby<TruncateTableContextProxy*> {
  public:
    VALUE convert(TruncateTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TruncateTableContextProxy>(x, false, rb_cTruncateTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectStatementContext*> {
  public:
    VALUE convert(MySqlParser::SelectStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectStatementContext>(x, false, rb_cSelectStatementContext);
    }
  };

  template <>
  class To_Ruby<SelectStatementContextProxy*> {
  public:
    VALUE convert(SelectStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectStatementContextProxy>(x, false, rb_cSelectStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InsertStatementContext*> {
  public:
    VALUE convert(MySqlParser::InsertStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InsertStatementContext>(x, false, rb_cInsertStatementContext);
    }
  };

  template <>
  class To_Ruby<InsertStatementContextProxy*> {
  public:
    VALUE convert(InsertStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InsertStatementContextProxy>(x, false, rb_cInsertStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UpdateStatementContext*> {
  public:
    VALUE convert(MySqlParser::UpdateStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UpdateStatementContext>(x, false, rb_cUpdateStatementContext);
    }
  };

  template <>
  class To_Ruby<UpdateStatementContextProxy*> {
  public:
    VALUE convert(UpdateStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UpdateStatementContextProxy>(x, false, rb_cUpdateStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeleteStatementContext*> {
  public:
    VALUE convert(MySqlParser::DeleteStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeleteStatementContext>(x, false, rb_cDeleteStatementContext);
    }
  };

  template <>
  class To_Ruby<DeleteStatementContextProxy*> {
  public:
    VALUE convert(DeleteStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeleteStatementContextProxy>(x, false, rb_cDeleteStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReplaceStatementContext*> {
  public:
    VALUE convert(MySqlParser::ReplaceStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReplaceStatementContext>(x, false, rb_cReplaceStatementContext);
    }
  };

  template <>
  class To_Ruby<ReplaceStatementContextProxy*> {
  public:
    VALUE convert(ReplaceStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReplaceStatementContextProxy>(x, false, rb_cReplaceStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CallStatementContext*> {
  public:
    VALUE convert(MySqlParser::CallStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CallStatementContext>(x, false, rb_cCallStatementContext);
    }
  };

  template <>
  class To_Ruby<CallStatementContextProxy*> {
  public:
    VALUE convert(CallStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CallStatementContextProxy>(x, false, rb_cCallStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LoadDataStatementContext*> {
  public:
    VALUE convert(MySqlParser::LoadDataStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LoadDataStatementContext>(x, false, rb_cLoadDataStatementContext);
    }
  };

  template <>
  class To_Ruby<LoadDataStatementContextProxy*> {
  public:
    VALUE convert(LoadDataStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LoadDataStatementContextProxy>(x, false, rb_cLoadDataStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LoadXmlStatementContext*> {
  public:
    VALUE convert(MySqlParser::LoadXmlStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LoadXmlStatementContext>(x, false, rb_cLoadXmlStatementContext);
    }
  };

  template <>
  class To_Ruby<LoadXmlStatementContextProxy*> {
  public:
    VALUE convert(LoadXmlStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LoadXmlStatementContextProxy>(x, false, rb_cLoadXmlStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DoStatementContext*> {
  public:
    VALUE convert(MySqlParser::DoStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DoStatementContext>(x, false, rb_cDoStatementContext);
    }
  };

  template <>
  class To_Ruby<DoStatementContextProxy*> {
  public:
    VALUE convert(DoStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DoStatementContextProxy>(x, false, rb_cDoStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerStatementContext*> {
  public:
    VALUE convert(MySqlParser::HandlerStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerStatementContext>(x, false, rb_cHandlerStatementContext);
    }
  };

  template <>
  class To_Ruby<HandlerStatementContextProxy*> {
  public:
    VALUE convert(HandlerStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerStatementContextProxy>(x, false, rb_cHandlerStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ValuesStatementContext*> {
  public:
    VALUE convert(MySqlParser::ValuesStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ValuesStatementContext>(x, false, rb_cValuesStatementContext);
    }
  };

  template <>
  class To_Ruby<ValuesStatementContextProxy*> {
  public:
    VALUE convert(ValuesStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ValuesStatementContextProxy>(x, false, rb_cValuesStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WithStatementContext*> {
  public:
    VALUE convert(MySqlParser::WithStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WithStatementContext>(x, false, rb_cWithStatementContext);
    }
  };

  template <>
  class To_Ruby<WithStatementContextProxy*> {
  public:
    VALUE convert(WithStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WithStatementContextProxy>(x, false, rb_cWithStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableStatementContext*> {
  public:
    VALUE convert(MySqlParser::TableStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableStatementContext>(x, false, rb_cTableStatementContext);
    }
  };

  template <>
  class To_Ruby<TableStatementContextProxy*> {
  public:
    VALUE convert(TableStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableStatementContextProxy>(x, false, rb_cTableStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StartTransactionContext*> {
  public:
    VALUE convert(MySqlParser::StartTransactionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StartTransactionContext>(x, false, rb_cStartTransactionContext);
    }
  };

  template <>
  class To_Ruby<StartTransactionContextProxy*> {
  public:
    VALUE convert(StartTransactionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StartTransactionContextProxy>(x, false, rb_cStartTransactionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BeginWorkContext*> {
  public:
    VALUE convert(MySqlParser::BeginWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BeginWorkContext>(x, false, rb_cBeginWorkContext);
    }
  };

  template <>
  class To_Ruby<BeginWorkContextProxy*> {
  public:
    VALUE convert(BeginWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BeginWorkContextProxy>(x, false, rb_cBeginWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CommitWorkContext*> {
  public:
    VALUE convert(MySqlParser::CommitWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CommitWorkContext>(x, false, rb_cCommitWorkContext);
    }
  };

  template <>
  class To_Ruby<CommitWorkContextProxy*> {
  public:
    VALUE convert(CommitWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CommitWorkContextProxy>(x, false, rb_cCommitWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RollbackWorkContext*> {
  public:
    VALUE convert(MySqlParser::RollbackWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RollbackWorkContext>(x, false, rb_cRollbackWorkContext);
    }
  };

  template <>
  class To_Ruby<RollbackWorkContextProxy*> {
  public:
    VALUE convert(RollbackWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RollbackWorkContextProxy>(x, false, rb_cRollbackWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SavepointStatementContext*> {
  public:
    VALUE convert(MySqlParser::SavepointStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SavepointStatementContext>(x, false, rb_cSavepointStatementContext);
    }
  };

  template <>
  class To_Ruby<SavepointStatementContextProxy*> {
  public:
    VALUE convert(SavepointStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SavepointStatementContextProxy>(x, false, rb_cSavepointStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RollbackStatementContext*> {
  public:
    VALUE convert(MySqlParser::RollbackStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RollbackStatementContext>(x, false, rb_cRollbackStatementContext);
    }
  };

  template <>
  class To_Ruby<RollbackStatementContextProxy*> {
  public:
    VALUE convert(RollbackStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RollbackStatementContextProxy>(x, false, rb_cRollbackStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReleaseStatementContext*> {
  public:
    VALUE convert(MySqlParser::ReleaseStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReleaseStatementContext>(x, false, rb_cReleaseStatementContext);
    }
  };

  template <>
  class To_Ruby<ReleaseStatementContextProxy*> {
  public:
    VALUE convert(ReleaseStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReleaseStatementContextProxy>(x, false, rb_cReleaseStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LockTablesContext*> {
  public:
    VALUE convert(MySqlParser::LockTablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LockTablesContext>(x, false, rb_cLockTablesContext);
    }
  };

  template <>
  class To_Ruby<LockTablesContextProxy*> {
  public:
    VALUE convert(LockTablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LockTablesContextProxy>(x, false, rb_cLockTablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnlockTablesContext*> {
  public:
    VALUE convert(MySqlParser::UnlockTablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnlockTablesContext>(x, false, rb_cUnlockTablesContext);
    }
  };

  template <>
  class To_Ruby<UnlockTablesContextProxy*> {
  public:
    VALUE convert(UnlockTablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnlockTablesContextProxy>(x, false, rb_cUnlockTablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ChangeMasterContext*> {
  public:
    VALUE convert(MySqlParser::ChangeMasterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ChangeMasterContext>(x, false, rb_cChangeMasterContext);
    }
  };

  template <>
  class To_Ruby<ChangeMasterContextProxy*> {
  public:
    VALUE convert(ChangeMasterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ChangeMasterContextProxy>(x, false, rb_cChangeMasterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ChangeReplicationFilterContext*> {
  public:
    VALUE convert(MySqlParser::ChangeReplicationFilterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ChangeReplicationFilterContext>(x, false, rb_cChangeReplicationFilterContext);
    }
  };

  template <>
  class To_Ruby<ChangeReplicationFilterContextProxy*> {
  public:
    VALUE convert(ChangeReplicationFilterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ChangeReplicationFilterContextProxy>(x, false, rb_cChangeReplicationFilterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PurgeBinaryLogsContext*> {
  public:
    VALUE convert(MySqlParser::PurgeBinaryLogsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PurgeBinaryLogsContext>(x, false, rb_cPurgeBinaryLogsContext);
    }
  };

  template <>
  class To_Ruby<PurgeBinaryLogsContextProxy*> {
  public:
    VALUE convert(PurgeBinaryLogsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PurgeBinaryLogsContextProxy>(x, false, rb_cPurgeBinaryLogsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ResetMasterContext*> {
  public:
    VALUE convert(MySqlParser::ResetMasterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ResetMasterContext>(x, false, rb_cResetMasterContext);
    }
  };

  template <>
  class To_Ruby<ResetMasterContextProxy*> {
  public:
    VALUE convert(ResetMasterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ResetMasterContextProxy>(x, false, rb_cResetMasterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ResetSlaveContext*> {
  public:
    VALUE convert(MySqlParser::ResetSlaveContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ResetSlaveContext>(x, false, rb_cResetSlaveContext);
    }
  };

  template <>
  class To_Ruby<ResetSlaveContextProxy*> {
  public:
    VALUE convert(ResetSlaveContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ResetSlaveContextProxy>(x, false, rb_cResetSlaveContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StartSlaveContext*> {
  public:
    VALUE convert(MySqlParser::StartSlaveContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StartSlaveContext>(x, false, rb_cStartSlaveContext);
    }
  };

  template <>
  class To_Ruby<StartSlaveContextProxy*> {
  public:
    VALUE convert(StartSlaveContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StartSlaveContextProxy>(x, false, rb_cStartSlaveContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StopSlaveContext*> {
  public:
    VALUE convert(MySqlParser::StopSlaveContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StopSlaveContext>(x, false, rb_cStopSlaveContext);
    }
  };

  template <>
  class To_Ruby<StopSlaveContextProxy*> {
  public:
    VALUE convert(StopSlaveContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StopSlaveContextProxy>(x, false, rb_cStopSlaveContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StartGroupReplicationContext*> {
  public:
    VALUE convert(MySqlParser::StartGroupReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StartGroupReplicationContext>(x, false, rb_cStartGroupReplicationContext);
    }
  };

  template <>
  class To_Ruby<StartGroupReplicationContextProxy*> {
  public:
    VALUE convert(StartGroupReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StartGroupReplicationContextProxy>(x, false, rb_cStartGroupReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StopGroupReplicationContext*> {
  public:
    VALUE convert(MySqlParser::StopGroupReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StopGroupReplicationContext>(x, false, rb_cStopGroupReplicationContext);
    }
  };

  template <>
  class To_Ruby<StopGroupReplicationContextProxy*> {
  public:
    VALUE convert(StopGroupReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StopGroupReplicationContextProxy>(x, false, rb_cStopGroupReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaStartTransactionContext*> {
  public:
    VALUE convert(MySqlParser::XaStartTransactionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaStartTransactionContext>(x, false, rb_cXaStartTransactionContext);
    }
  };

  template <>
  class To_Ruby<XaStartTransactionContextProxy*> {
  public:
    VALUE convert(XaStartTransactionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaStartTransactionContextProxy>(x, false, rb_cXaStartTransactionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaEndTransactionContext*> {
  public:
    VALUE convert(MySqlParser::XaEndTransactionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaEndTransactionContext>(x, false, rb_cXaEndTransactionContext);
    }
  };

  template <>
  class To_Ruby<XaEndTransactionContextProxy*> {
  public:
    VALUE convert(XaEndTransactionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaEndTransactionContextProxy>(x, false, rb_cXaEndTransactionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaPrepareStatementContext*> {
  public:
    VALUE convert(MySqlParser::XaPrepareStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaPrepareStatementContext>(x, false, rb_cXaPrepareStatementContext);
    }
  };

  template <>
  class To_Ruby<XaPrepareStatementContextProxy*> {
  public:
    VALUE convert(XaPrepareStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaPrepareStatementContextProxy>(x, false, rb_cXaPrepareStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaCommitWorkContext*> {
  public:
    VALUE convert(MySqlParser::XaCommitWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaCommitWorkContext>(x, false, rb_cXaCommitWorkContext);
    }
  };

  template <>
  class To_Ruby<XaCommitWorkContextProxy*> {
  public:
    VALUE convert(XaCommitWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaCommitWorkContextProxy>(x, false, rb_cXaCommitWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaRollbackWorkContext*> {
  public:
    VALUE convert(MySqlParser::XaRollbackWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaRollbackWorkContext>(x, false, rb_cXaRollbackWorkContext);
    }
  };

  template <>
  class To_Ruby<XaRollbackWorkContextProxy*> {
  public:
    VALUE convert(XaRollbackWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaRollbackWorkContextProxy>(x, false, rb_cXaRollbackWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XaRecoverWorkContext*> {
  public:
    VALUE convert(MySqlParser::XaRecoverWorkContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XaRecoverWorkContext>(x, false, rb_cXaRecoverWorkContext);
    }
  };

  template <>
  class To_Ruby<XaRecoverWorkContextProxy*> {
  public:
    VALUE convert(XaRecoverWorkContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XaRecoverWorkContextProxy>(x, false, rb_cXaRecoverWorkContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrepareStatementContext*> {
  public:
    VALUE convert(MySqlParser::PrepareStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrepareStatementContext>(x, false, rb_cPrepareStatementContext);
    }
  };

  template <>
  class To_Ruby<PrepareStatementContextProxy*> {
  public:
    VALUE convert(PrepareStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrepareStatementContextProxy>(x, false, rb_cPrepareStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExecuteStatementContext*> {
  public:
    VALUE convert(MySqlParser::ExecuteStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExecuteStatementContext>(x, false, rb_cExecuteStatementContext);
    }
  };

  template <>
  class To_Ruby<ExecuteStatementContextProxy*> {
  public:
    VALUE convert(ExecuteStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExecuteStatementContextProxy>(x, false, rb_cExecuteStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeallocatePrepareContext*> {
  public:
    VALUE convert(MySqlParser::DeallocatePrepareContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeallocatePrepareContext>(x, false, rb_cDeallocatePrepareContext);
    }
  };

  template <>
  class To_Ruby<DeallocatePrepareContextProxy*> {
  public:
    VALUE convert(DeallocatePrepareContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeallocatePrepareContextProxy>(x, false, rb_cDeallocatePrepareContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CompoundStatementContext*> {
  public:
    VALUE convert(MySqlParser::CompoundStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CompoundStatementContext>(x, false, rb_cCompoundStatementContext);
    }
  };

  template <>
  class To_Ruby<CompoundStatementContextProxy*> {
  public:
    VALUE convert(CompoundStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CompoundStatementContextProxy>(x, false, rb_cCompoundStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BlockStatementContext*> {
  public:
    VALUE convert(MySqlParser::BlockStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BlockStatementContext>(x, false, rb_cBlockStatementContext);
    }
  };

  template <>
  class To_Ruby<BlockStatementContextProxy*> {
  public:
    VALUE convert(BlockStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BlockStatementContextProxy>(x, false, rb_cBlockStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CaseStatementContext*> {
  public:
    VALUE convert(MySqlParser::CaseStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CaseStatementContext>(x, false, rb_cCaseStatementContext);
    }
  };

  template <>
  class To_Ruby<CaseStatementContextProxy*> {
  public:
    VALUE convert(CaseStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CaseStatementContextProxy>(x, false, rb_cCaseStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IfStatementContext*> {
  public:
    VALUE convert(MySqlParser::IfStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IfStatementContext>(x, false, rb_cIfStatementContext);
    }
  };

  template <>
  class To_Ruby<IfStatementContextProxy*> {
  public:
    VALUE convert(IfStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IfStatementContextProxy>(x, false, rb_cIfStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LeaveStatementContext*> {
  public:
    VALUE convert(MySqlParser::LeaveStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LeaveStatementContext>(x, false, rb_cLeaveStatementContext);
    }
  };

  template <>
  class To_Ruby<LeaveStatementContextProxy*> {
  public:
    VALUE convert(LeaveStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LeaveStatementContextProxy>(x, false, rb_cLeaveStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LoopStatementContext*> {
  public:
    VALUE convert(MySqlParser::LoopStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LoopStatementContext>(x, false, rb_cLoopStatementContext);
    }
  };

  template <>
  class To_Ruby<LoopStatementContextProxy*> {
  public:
    VALUE convert(LoopStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LoopStatementContextProxy>(x, false, rb_cLoopStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RepeatStatementContext*> {
  public:
    VALUE convert(MySqlParser::RepeatStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RepeatStatementContext>(x, false, rb_cRepeatStatementContext);
    }
  };

  template <>
  class To_Ruby<RepeatStatementContextProxy*> {
  public:
    VALUE convert(RepeatStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RepeatStatementContextProxy>(x, false, rb_cRepeatStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WhileStatementContext*> {
  public:
    VALUE convert(MySqlParser::WhileStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WhileStatementContext>(x, false, rb_cWhileStatementContext);
    }
  };

  template <>
  class To_Ruby<WhileStatementContextProxy*> {
  public:
    VALUE convert(WhileStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WhileStatementContextProxy>(x, false, rb_cWhileStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IterateStatementContext*> {
  public:
    VALUE convert(MySqlParser::IterateStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IterateStatementContext>(x, false, rb_cIterateStatementContext);
    }
  };

  template <>
  class To_Ruby<IterateStatementContextProxy*> {
  public:
    VALUE convert(IterateStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IterateStatementContextProxy>(x, false, rb_cIterateStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReturnStatementContext*> {
  public:
    VALUE convert(MySqlParser::ReturnStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReturnStatementContext>(x, false, rb_cReturnStatementContext);
    }
  };

  template <>
  class To_Ruby<ReturnStatementContextProxy*> {
  public:
    VALUE convert(ReturnStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReturnStatementContextProxy>(x, false, rb_cReturnStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CursorStatementContext*> {
  public:
    VALUE convert(MySqlParser::CursorStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CursorStatementContext>(x, false, rb_cCursorStatementContext);
    }
  };

  template <>
  class To_Ruby<CursorStatementContextProxy*> {
  public:
    VALUE convert(CursorStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CursorStatementContextProxy>(x, false, rb_cCursorStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterUserContext*> {
  public:
    VALUE convert(MySqlParser::AlterUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterUserContext>(x, false, rb_cAlterUserContext);
    }
  };

  template <>
  class To_Ruby<AlterUserContextProxy*> {
  public:
    VALUE convert(AlterUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterUserContextProxy>(x, false, rb_cAlterUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateUserContext*> {
  public:
    VALUE convert(MySqlParser::CreateUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateUserContext>(x, false, rb_cCreateUserContext);
    }
  };

  template <>
  class To_Ruby<CreateUserContextProxy*> {
  public:
    VALUE convert(CreateUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateUserContextProxy>(x, false, rb_cCreateUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DropUserContext*> {
  public:
    VALUE convert(MySqlParser::DropUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DropUserContext>(x, false, rb_cDropUserContext);
    }
  };

  template <>
  class To_Ruby<DropUserContextProxy*> {
  public:
    VALUE convert(DropUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DropUserContextProxy>(x, false, rb_cDropUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GrantStatementContext*> {
  public:
    VALUE convert(MySqlParser::GrantStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GrantStatementContext>(x, false, rb_cGrantStatementContext);
    }
  };

  template <>
  class To_Ruby<GrantStatementContextProxy*> {
  public:
    VALUE convert(GrantStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GrantStatementContextProxy>(x, false, rb_cGrantStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GrantProxyContext*> {
  public:
    VALUE convert(MySqlParser::GrantProxyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GrantProxyContext>(x, false, rb_cGrantProxyContext);
    }
  };

  template <>
  class To_Ruby<GrantProxyContextProxy*> {
  public:
    VALUE convert(GrantProxyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GrantProxyContextProxy>(x, false, rb_cGrantProxyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RenameUserContext*> {
  public:
    VALUE convert(MySqlParser::RenameUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RenameUserContext>(x, false, rb_cRenameUserContext);
    }
  };

  template <>
  class To_Ruby<RenameUserContextProxy*> {
  public:
    VALUE convert(RenameUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RenameUserContextProxy>(x, false, rb_cRenameUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RevokeStatementContext*> {
  public:
    VALUE convert(MySqlParser::RevokeStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RevokeStatementContext>(x, false, rb_cRevokeStatementContext);
    }
  };

  template <>
  class To_Ruby<RevokeStatementContextProxy*> {
  public:
    VALUE convert(RevokeStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RevokeStatementContextProxy>(x, false, rb_cRevokeStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RevokeProxyContext*> {
  public:
    VALUE convert(MySqlParser::RevokeProxyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RevokeProxyContext>(x, false, rb_cRevokeProxyContext);
    }
  };

  template <>
  class To_Ruby<RevokeProxyContextProxy*> {
  public:
    VALUE convert(RevokeProxyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RevokeProxyContextProxy>(x, false, rb_cRevokeProxyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AnalyzeTableContext*> {
  public:
    VALUE convert(MySqlParser::AnalyzeTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AnalyzeTableContext>(x, false, rb_cAnalyzeTableContext);
    }
  };

  template <>
  class To_Ruby<AnalyzeTableContextProxy*> {
  public:
    VALUE convert(AnalyzeTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AnalyzeTableContextProxy>(x, false, rb_cAnalyzeTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CheckTableContext*> {
  public:
    VALUE convert(MySqlParser::CheckTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CheckTableContext>(x, false, rb_cCheckTableContext);
    }
  };

  template <>
  class To_Ruby<CheckTableContextProxy*> {
  public:
    VALUE convert(CheckTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CheckTableContextProxy>(x, false, rb_cCheckTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ChecksumTableContext*> {
  public:
    VALUE convert(MySqlParser::ChecksumTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ChecksumTableContext>(x, false, rb_cChecksumTableContext);
    }
  };

  template <>
  class To_Ruby<ChecksumTableContextProxy*> {
  public:
    VALUE convert(ChecksumTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ChecksumTableContextProxy>(x, false, rb_cChecksumTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OptimizeTableContext*> {
  public:
    VALUE convert(MySqlParser::OptimizeTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OptimizeTableContext>(x, false, rb_cOptimizeTableContext);
    }
  };

  template <>
  class To_Ruby<OptimizeTableContextProxy*> {
  public:
    VALUE convert(OptimizeTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OptimizeTableContextProxy>(x, false, rb_cOptimizeTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RepairTableContext*> {
  public:
    VALUE convert(MySqlParser::RepairTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RepairTableContext>(x, false, rb_cRepairTableContext);
    }
  };

  template <>
  class To_Ruby<RepairTableContextProxy*> {
  public:
    VALUE convert(RepairTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RepairTableContextProxy>(x, false, rb_cRepairTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateUdfunctionContext*> {
  public:
    VALUE convert(MySqlParser::CreateUdfunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateUdfunctionContext>(x, false, rb_cCreateUdfunctionContext);
    }
  };

  template <>
  class To_Ruby<CreateUdfunctionContextProxy*> {
  public:
    VALUE convert(CreateUdfunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateUdfunctionContextProxy>(x, false, rb_cCreateUdfunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InstallPluginContext*> {
  public:
    VALUE convert(MySqlParser::InstallPluginContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InstallPluginContext>(x, false, rb_cInstallPluginContext);
    }
  };

  template <>
  class To_Ruby<InstallPluginContextProxy*> {
  public:
    VALUE convert(InstallPluginContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InstallPluginContextProxy>(x, false, rb_cInstallPluginContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UninstallPluginContext*> {
  public:
    VALUE convert(MySqlParser::UninstallPluginContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UninstallPluginContext>(x, false, rb_cUninstallPluginContext);
    }
  };

  template <>
  class To_Ruby<UninstallPluginContextProxy*> {
  public:
    VALUE convert(UninstallPluginContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UninstallPluginContextProxy>(x, false, rb_cUninstallPluginContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetStatementContext*> {
  public:
    VALUE convert(MySqlParser::SetStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetStatementContext>(x, false, rb_cSetStatementContext);
    }
  };

  template <>
  class To_Ruby<SetStatementContextProxy*> {
  public:
    VALUE convert(SetStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetStatementContextProxy>(x, false, rb_cSetStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowStatementContext*> {
  public:
    VALUE convert(MySqlParser::ShowStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowStatementContext>(x, false, rb_cShowStatementContext);
    }
  };

  template <>
  class To_Ruby<ShowStatementContextProxy*> {
  public:
    VALUE convert(ShowStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowStatementContextProxy>(x, false, rb_cShowStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BinlogStatementContext*> {
  public:
    VALUE convert(MySqlParser::BinlogStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BinlogStatementContext>(x, false, rb_cBinlogStatementContext);
    }
  };

  template <>
  class To_Ruby<BinlogStatementContextProxy*> {
  public:
    VALUE convert(BinlogStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BinlogStatementContextProxy>(x, false, rb_cBinlogStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CacheIndexStatementContext*> {
  public:
    VALUE convert(MySqlParser::CacheIndexStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CacheIndexStatementContext>(x, false, rb_cCacheIndexStatementContext);
    }
  };

  template <>
  class To_Ruby<CacheIndexStatementContextProxy*> {
  public:
    VALUE convert(CacheIndexStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CacheIndexStatementContextProxy>(x, false, rb_cCacheIndexStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FlushStatementContext*> {
  public:
    VALUE convert(MySqlParser::FlushStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FlushStatementContext>(x, false, rb_cFlushStatementContext);
    }
  };

  template <>
  class To_Ruby<FlushStatementContextProxy*> {
  public:
    VALUE convert(FlushStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FlushStatementContextProxy>(x, false, rb_cFlushStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::KillStatementContext*> {
  public:
    VALUE convert(MySqlParser::KillStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::KillStatementContext>(x, false, rb_cKillStatementContext);
    }
  };

  template <>
  class To_Ruby<KillStatementContextProxy*> {
  public:
    VALUE convert(KillStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<KillStatementContextProxy>(x, false, rb_cKillStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LoadIndexIntoCacheContext*> {
  public:
    VALUE convert(MySqlParser::LoadIndexIntoCacheContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LoadIndexIntoCacheContext>(x, false, rb_cLoadIndexIntoCacheContext);
    }
  };

  template <>
  class To_Ruby<LoadIndexIntoCacheContextProxy*> {
  public:
    VALUE convert(LoadIndexIntoCacheContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LoadIndexIntoCacheContextProxy>(x, false, rb_cLoadIndexIntoCacheContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ResetStatementContext*> {
  public:
    VALUE convert(MySqlParser::ResetStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ResetStatementContext>(x, false, rb_cResetStatementContext);
    }
  };

  template <>
  class To_Ruby<ResetStatementContextProxy*> {
  public:
    VALUE convert(ResetStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ResetStatementContextProxy>(x, false, rb_cResetStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShutdownStatementContext*> {
  public:
    VALUE convert(MySqlParser::ShutdownStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShutdownStatementContext>(x, false, rb_cShutdownStatementContext);
    }
  };

  template <>
  class To_Ruby<ShutdownStatementContextProxy*> {
  public:
    VALUE convert(ShutdownStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShutdownStatementContextProxy>(x, false, rb_cShutdownStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleDescribeStatementContext*> {
  public:
    VALUE convert(MySqlParser::SimpleDescribeStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleDescribeStatementContext>(x, false, rb_cSimpleDescribeStatementContext);
    }
  };

  template <>
  class To_Ruby<SimpleDescribeStatementContextProxy*> {
  public:
    VALUE convert(SimpleDescribeStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleDescribeStatementContextProxy>(x, false, rb_cSimpleDescribeStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FullDescribeStatementContext*> {
  public:
    VALUE convert(MySqlParser::FullDescribeStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FullDescribeStatementContext>(x, false, rb_cFullDescribeStatementContext);
    }
  };

  template <>
  class To_Ruby<FullDescribeStatementContextProxy*> {
  public:
    VALUE convert(FullDescribeStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FullDescribeStatementContextProxy>(x, false, rb_cFullDescribeStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HelpStatementContext*> {
  public:
    VALUE convert(MySqlParser::HelpStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HelpStatementContext>(x, false, rb_cHelpStatementContext);
    }
  };

  template <>
  class To_Ruby<HelpStatementContextProxy*> {
  public:
    VALUE convert(HelpStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HelpStatementContextProxy>(x, false, rb_cHelpStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UseStatementContext*> {
  public:
    VALUE convert(MySqlParser::UseStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UseStatementContext>(x, false, rb_cUseStatementContext);
    }
  };

  template <>
  class To_Ruby<UseStatementContextProxy*> {
  public:
    VALUE convert(UseStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UseStatementContextProxy>(x, false, rb_cUseStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SignalStatementContext*> {
  public:
    VALUE convert(MySqlParser::SignalStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SignalStatementContext>(x, false, rb_cSignalStatementContext);
    }
  };

  template <>
  class To_Ruby<SignalStatementContextProxy*> {
  public:
    VALUE convert(SignalStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SignalStatementContextProxy>(x, false, rb_cSignalStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ResignalStatementContext*> {
  public:
    VALUE convert(MySqlParser::ResignalStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ResignalStatementContext>(x, false, rb_cResignalStatementContext);
    }
  };

  template <>
  class To_Ruby<ResignalStatementContextProxy*> {
  public:
    VALUE convert(ResignalStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ResignalStatementContextProxy>(x, false, rb_cResignalStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DiagnosticsStatementContext*> {
  public:
    VALUE convert(MySqlParser::DiagnosticsStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DiagnosticsStatementContext>(x, false, rb_cDiagnosticsStatementContext);
    }
  };

  template <>
  class To_Ruby<DiagnosticsStatementContextProxy*> {
  public:
    VALUE convert(DiagnosticsStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DiagnosticsStatementContextProxy>(x, false, rb_cDiagnosticsStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UidContext*> {
  public:
    VALUE convert(MySqlParser::UidContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UidContext>(x, false, rb_cUidContext);
    }
  };

  template <>
  class To_Ruby<UidContextProxy*> {
  public:
    VALUE convert(UidContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UidContextProxy>(x, false, rb_cUidContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IfNotExistsContext*> {
  public:
    VALUE convert(MySqlParser::IfNotExistsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IfNotExistsContext>(x, false, rb_cIfNotExistsContext);
    }
  };

  template <>
  class To_Ruby<IfNotExistsContextProxy*> {
  public:
    VALUE convert(IfNotExistsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IfNotExistsContextProxy>(x, false, rb_cIfNotExistsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateDatabaseOptionContext*> {
  public:
    VALUE convert(MySqlParser::CreateDatabaseOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateDatabaseOptionContext>(x, false, rb_cCreateDatabaseOptionContext);
    }
  };

  template <>
  class To_Ruby<CreateDatabaseOptionContextProxy*> {
  public:
    VALUE convert(CreateDatabaseOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateDatabaseOptionContextProxy>(x, false, rb_cCreateDatabaseOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FullIdContext*> {
  public:
    VALUE convert(MySqlParser::FullIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FullIdContext>(x, false, rb_cFullIdContext);
    }
  };

  template <>
  class To_Ruby<FullIdContextProxy*> {
  public:
    VALUE convert(FullIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FullIdContextProxy>(x, false, rb_cFullIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ScheduleExpressionContext*> {
  public:
    VALUE convert(MySqlParser::ScheduleExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ScheduleExpressionContext>(x, false, rb_cScheduleExpressionContext);
    }
  };

  template <>
  class To_Ruby<ScheduleExpressionContextProxy*> {
  public:
    VALUE convert(ScheduleExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ScheduleExpressionContextProxy>(x, false, rb_cScheduleExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineBodyContext*> {
  public:
    VALUE convert(MySqlParser::RoutineBodyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineBodyContext>(x, false, rb_cRoutineBodyContext);
    }
  };

  template <>
  class To_Ruby<RoutineBodyContextProxy*> {
  public:
    VALUE convert(RoutineBodyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineBodyContextProxy>(x, false, rb_cRoutineBodyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OwnerStatementContext*> {
  public:
    VALUE convert(MySqlParser::OwnerStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OwnerStatementContext>(x, false, rb_cOwnerStatementContext);
    }
  };

  template <>
  class To_Ruby<OwnerStatementContextProxy*> {
  public:
    VALUE convert(OwnerStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OwnerStatementContextProxy>(x, false, rb_cOwnerStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::EnableTypeContext*> {
  public:
    VALUE convert(MySqlParser::EnableTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::EnableTypeContext>(x, false, rb_cEnableTypeContext);
    }
  };

  template <>
  class To_Ruby<EnableTypeContextProxy*> {
  public:
    VALUE convert(EnableTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<EnableTypeContextProxy>(x, false, rb_cEnableTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableNameContext*> {
  public:
    VALUE convert(MySqlParser::TableNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableNameContext>(x, false, rb_cTableNameContext);
    }
  };

  template <>
  class To_Ruby<TableNameContextProxy*> {
  public:
    VALUE convert(TableNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableNameContextProxy>(x, false, rb_cTableNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexColumnNamesContext*> {
  public:
    VALUE convert(MySqlParser::IndexColumnNamesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexColumnNamesContext>(x, false, rb_cIndexColumnNamesContext);
    }
  };

  template <>
  class To_Ruby<IndexColumnNamesContextProxy*> {
  public:
    VALUE convert(IndexColumnNamesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexColumnNamesContextProxy>(x, false, rb_cIndexColumnNamesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexTypeContext*> {
  public:
    VALUE convert(MySqlParser::IndexTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexTypeContext>(x, false, rb_cIndexTypeContext);
    }
  };

  template <>
  class To_Ruby<IndexTypeContextProxy*> {
  public:
    VALUE convert(IndexTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexTypeContextProxy>(x, false, rb_cIndexTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexOptionContext*> {
  public:
    VALUE convert(MySqlParser::IndexOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexOptionContext>(x, false, rb_cIndexOptionContext);
    }
  };

  template <>
  class To_Ruby<IndexOptionContextProxy*> {
  public:
    VALUE convert(IndexOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexOptionContextProxy>(x, false, rb_cIndexOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::EngineNameContext*> {
  public:
    VALUE convert(MySqlParser::EngineNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::EngineNameContext>(x, false, rb_cEngineNameContext);
    }
  };

  template <>
  class To_Ruby<EngineNameContextProxy*> {
  public:
    VALUE convert(EngineNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<EngineNameContextProxy>(x, false, rb_cEngineNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FileSizeLiteralContext*> {
  public:
    VALUE convert(MySqlParser::FileSizeLiteralContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FileSizeLiteralContext>(x, false, rb_cFileSizeLiteralContext);
    }
  };

  template <>
  class To_Ruby<FileSizeLiteralContextProxy*> {
  public:
    VALUE convert(FileSizeLiteralContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FileSizeLiteralContextProxy>(x, false, rb_cFileSizeLiteralContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ProcedureParameterContext*> {
  public:
    VALUE convert(MySqlParser::ProcedureParameterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ProcedureParameterContext>(x, false, rb_cProcedureParameterContext);
    }
  };

  template <>
  class To_Ruby<ProcedureParameterContextProxy*> {
  public:
    VALUE convert(ProcedureParameterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ProcedureParameterContextProxy>(x, false, rb_cProcedureParameterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineOptionContext*> {
  public:
    VALUE convert(MySqlParser::RoutineOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineOptionContext>(x, false, rb_cRoutineOptionContext);
    }
  };

  template <>
  class To_Ruby<RoutineOptionContextProxy*> {
  public:
    VALUE convert(RoutineOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineOptionContextProxy>(x, false, rb_cRoutineOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DataTypeContext*> {
  public:
    VALUE convert(MySqlParser::DataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DataTypeContext>(x, false, rb_cDataTypeContext);
    }
  };

  template <>
  class To_Ruby<DataTypeContextProxy*> {
  public:
    VALUE convert(DataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DataTypeContextProxy>(x, false, rb_cDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionParameterContext*> {
  public:
    VALUE convert(MySqlParser::FunctionParameterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionParameterContext>(x, false, rb_cFunctionParameterContext);
    }
  };

  template <>
  class To_Ruby<FunctionParameterContextProxy*> {
  public:
    VALUE convert(FunctionParameterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionParameterContextProxy>(x, false, rb_cFunctionParameterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoleNameContext*> {
  public:
    VALUE convert(MySqlParser::RoleNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoleNameContext>(x, false, rb_cRoleNameContext);
    }
  };

  template <>
  class To_Ruby<RoleNameContextProxy*> {
  public:
    VALUE convert(RoleNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoleNameContextProxy>(x, false, rb_cRoleNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ServerOptionContext*> {
  public:
    VALUE convert(MySqlParser::ServerOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ServerOptionContext>(x, false, rb_cServerOptionContext);
    }
  };

  template <>
  class To_Ruby<ServerOptionContextProxy*> {
  public:
    VALUE convert(ServerOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ServerOptionContextProxy>(x, false, rb_cServerOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CopyCreateTableContext*> {
  public:
    VALUE convert(MySqlParser::CopyCreateTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CopyCreateTableContext>(x, false, rb_cCopyCreateTableContext);
    }
  };

  template <>
  class To_Ruby<CopyCreateTableContextProxy*> {
  public:
    VALUE convert(CopyCreateTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CopyCreateTableContextProxy>(x, false, rb_cCopyCreateTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ColumnCreateTableContext*> {
  public:
    VALUE convert(MySqlParser::ColumnCreateTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ColumnCreateTableContext>(x, false, rb_cColumnCreateTableContext);
    }
  };

  template <>
  class To_Ruby<ColumnCreateTableContextProxy*> {
  public:
    VALUE convert(ColumnCreateTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ColumnCreateTableContextProxy>(x, false, rb_cColumnCreateTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateDefinitionsContext*> {
  public:
    VALUE convert(MySqlParser::CreateDefinitionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateDefinitionsContext>(x, false, rb_cCreateDefinitionsContext);
    }
  };

  template <>
  class To_Ruby<CreateDefinitionsContextProxy*> {
  public:
    VALUE convert(CreateDefinitionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateDefinitionsContextProxy>(x, false, rb_cCreateDefinitionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionContext>(x, false, rb_cTableOptionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionContextProxy*> {
  public:
    VALUE convert(TableOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionContextProxy>(x, false, rb_cTableOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionDefinitionsContext*> {
  public:
    VALUE convert(MySqlParser::PartitionDefinitionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionDefinitionsContext>(x, false, rb_cPartitionDefinitionsContext);
    }
  };

  template <>
  class To_Ruby<PartitionDefinitionsContextProxy*> {
  public:
    VALUE convert(PartitionDefinitionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionDefinitionsContextProxy>(x, false, rb_cPartitionDefinitionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::QueryCreateTableContext*> {
  public:
    VALUE convert(MySqlParser::QueryCreateTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::QueryCreateTableContext>(x, false, rb_cQueryCreateTableContext);
    }
  };

  template <>
  class To_Ruby<QueryCreateTableContextProxy*> {
  public:
    VALUE convert(QueryCreateTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<QueryCreateTableContextProxy>(x, false, rb_cQueryCreateTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WithClauseContext*> {
  public:
    VALUE convert(MySqlParser::WithClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WithClauseContext>(x, false, rb_cWithClauseContext);
    }
  };

  template <>
  class To_Ruby<WithClauseContextProxy*> {
  public:
    VALUE convert(WithClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WithClauseContextProxy>(x, false, rb_cWithClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CommonTableExpressionsContext*> {
  public:
    VALUE convert(MySqlParser::CommonTableExpressionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CommonTableExpressionsContext>(x, false, rb_cCommonTableExpressionsContext);
    }
  };

  template <>
  class To_Ruby<CommonTableExpressionsContextProxy*> {
  public:
    VALUE convert(CommonTableExpressionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CommonTableExpressionsContextProxy>(x, false, rb_cCommonTableExpressionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CteNameContext*> {
  public:
    VALUE convert(MySqlParser::CteNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CteNameContext>(x, false, rb_cCteNameContext);
    }
  };

  template <>
  class To_Ruby<CteNameContextProxy*> {
  public:
    VALUE convert(CteNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CteNameContextProxy>(x, false, rb_cCteNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CteColumnNameContext*> {
  public:
    VALUE convert(MySqlParser::CteColumnNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CteColumnNameContext>(x, false, rb_cCteColumnNameContext);
    }
  };

  template <>
  class To_Ruby<CteColumnNameContextProxy*> {
  public:
    VALUE convert(CteColumnNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CteColumnNameContextProxy>(x, false, rb_cCteColumnNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OrReplaceContext*> {
  public:
    VALUE convert(MySqlParser::OrReplaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OrReplaceContext>(x, false, rb_cOrReplaceContext);
    }
  };

  template <>
  class To_Ruby<OrReplaceContextProxy*> {
  public:
    VALUE convert(OrReplaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OrReplaceContextProxy>(x, false, rb_cOrReplaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UidListContext*> {
  public:
    VALUE convert(MySqlParser::UidListContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UidListContext>(x, false, rb_cUidListContext);
    }
  };

  template <>
  class To_Ruby<UidListContextProxy*> {
  public:
    VALUE convert(UidListContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UidListContextProxy>(x, false, rb_cUidListContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CharSetContext*> {
  public:
    VALUE convert(MySqlParser::CharSetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CharSetContext>(x, false, rb_cCharSetContext);
    }
  };

  template <>
  class To_Ruby<CharSetContextProxy*> {
  public:
    VALUE convert(CharSetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CharSetContextProxy>(x, false, rb_cCharSetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CharsetNameContext*> {
  public:
    VALUE convert(MySqlParser::CharsetNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CharsetNameContext>(x, false, rb_cCharsetNameContext);
    }
  };

  template <>
  class To_Ruby<CharsetNameContextProxy*> {
  public:
    VALUE convert(CharsetNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CharsetNameContextProxy>(x, false, rb_cCharsetNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CollationNameContext*> {
  public:
    VALUE convert(MySqlParser::CollationNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CollationNameContext>(x, false, rb_cCollationNameContext);
    }
  };

  template <>
  class To_Ruby<CollationNameContextProxy*> {
  public:
    VALUE convert(CollationNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CollationNameContextProxy>(x, false, rb_cCollationNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CurrentUserExpressionContext*> {
  public:
    VALUE convert(MySqlParser::CurrentUserExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CurrentUserExpressionContext>(x, false, rb_cCurrentUserExpressionContext);
    }
  };

  template <>
  class To_Ruby<CurrentUserExpressionContextProxy*> {
  public:
    VALUE convert(CurrentUserExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CurrentUserExpressionContextProxy>(x, false, rb_cCurrentUserExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserNameContext*> {
  public:
    VALUE convert(MySqlParser::UserNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserNameContext>(x, false, rb_cUserNameContext);
    }
  };

  template <>
  class To_Ruby<UserNameContextProxy*> {
  public:
    VALUE convert(UserNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserNameContextProxy>(x, false, rb_cUserNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PreciseScheduleContext*> {
  public:
    VALUE convert(MySqlParser::PreciseScheduleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PreciseScheduleContext>(x, false, rb_cPreciseScheduleContext);
    }
  };

  template <>
  class To_Ruby<PreciseScheduleContextProxy*> {
  public:
    VALUE convert(PreciseScheduleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PreciseScheduleContextProxy>(x, false, rb_cPreciseScheduleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TimestampValueContext*> {
  public:
    VALUE convert(MySqlParser::TimestampValueContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TimestampValueContext>(x, false, rb_cTimestampValueContext);
    }
  };

  template <>
  class To_Ruby<TimestampValueContextProxy*> {
  public:
    VALUE convert(TimestampValueContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TimestampValueContextProxy>(x, false, rb_cTimestampValueContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IntervalExprContext*> {
  public:
    VALUE convert(MySqlParser::IntervalExprContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IntervalExprContext>(x, false, rb_cIntervalExprContext);
    }
  };

  template <>
  class To_Ruby<IntervalExprContextProxy*> {
  public:
    VALUE convert(IntervalExprContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IntervalExprContextProxy>(x, false, rb_cIntervalExprContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IntervalScheduleContext*> {
  public:
    VALUE convert(MySqlParser::IntervalScheduleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IntervalScheduleContext>(x, false, rb_cIntervalScheduleContext);
    }
  };

  template <>
  class To_Ruby<IntervalScheduleContextProxy*> {
  public:
    VALUE convert(IntervalScheduleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IntervalScheduleContextProxy>(x, false, rb_cIntervalScheduleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IntervalTypeContext*> {
  public:
    VALUE convert(MySqlParser::IntervalTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IntervalTypeContext>(x, false, rb_cIntervalTypeContext);
    }
  };

  template <>
  class To_Ruby<IntervalTypeContextProxy*> {
  public:
    VALUE convert(IntervalTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IntervalTypeContextProxy>(x, false, rb_cIntervalTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DecimalLiteralContext*> {
  public:
    VALUE convert(MySqlParser::DecimalLiteralContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DecimalLiteralContext>(x, false, rb_cDecimalLiteralContext);
    }
  };

  template <>
  class To_Ruby<DecimalLiteralContextProxy*> {
  public:
    VALUE convert(DecimalLiteralContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DecimalLiteralContextProxy>(x, false, rb_cDecimalLiteralContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionContext>(x, false, rb_cExpressionContext);
    }
  };

  template <>
  class To_Ruby<ExpressionContextProxy*> {
  public:
    VALUE convert(ExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionContextProxy>(x, false, rb_cExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StringLiteralContext*> {
  public:
    VALUE convert(MySqlParser::StringLiteralContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StringLiteralContext>(x, false, rb_cStringLiteralContext);
    }
  };

  template <>
  class To_Ruby<StringLiteralContextProxy*> {
  public:
    VALUE convert(StringLiteralContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StringLiteralContextProxy>(x, false, rb_cStringLiteralContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IntervalTypeBaseContext*> {
  public:
    VALUE convert(MySqlParser::IntervalTypeBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IntervalTypeBaseContext>(x, false, rb_cIntervalTypeBaseContext);
    }
  };

  template <>
  class To_Ruby<IntervalTypeBaseContextProxy*> {
  public:
    VALUE convert(IntervalTypeBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IntervalTypeBaseContextProxy>(x, false, rb_cIntervalTypeBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineBehaviorContext*> {
  public:
    VALUE convert(MySqlParser::RoutineBehaviorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineBehaviorContext>(x, false, rb_cRoutineBehaviorContext);
    }
  };

  template <>
  class To_Ruby<RoutineBehaviorContextProxy*> {
  public:
    VALUE convert(RoutineBehaviorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineBehaviorContextProxy>(x, false, rb_cRoutineBehaviorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineLanguageContext*> {
  public:
    VALUE convert(MySqlParser::RoutineLanguageContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineLanguageContext>(x, false, rb_cRoutineLanguageContext);
    }
  };

  template <>
  class To_Ruby<RoutineLanguageContextProxy*> {
  public:
    VALUE convert(RoutineLanguageContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineLanguageContextProxy>(x, false, rb_cRoutineLanguageContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineCommentContext*> {
  public:
    VALUE convert(MySqlParser::RoutineCommentContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineCommentContext>(x, false, rb_cRoutineCommentContext);
    }
  };

  template <>
  class To_Ruby<RoutineCommentContextProxy*> {
  public:
    VALUE convert(RoutineCommentContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineCommentContextProxy>(x, false, rb_cRoutineCommentContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineSecurityContext*> {
  public:
    VALUE convert(MySqlParser::RoutineSecurityContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineSecurityContext>(x, false, rb_cRoutineSecurityContext);
    }
  };

  template <>
  class To_Ruby<RoutineSecurityContextProxy*> {
  public:
    VALUE convert(RoutineSecurityContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineSecurityContextProxy>(x, false, rb_cRoutineSecurityContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoutineDataContext*> {
  public:
    VALUE convert(MySqlParser::RoutineDataContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoutineDataContext>(x, false, rb_cRoutineDataContext);
    }
  };

  template <>
  class To_Ruby<RoutineDataContextProxy*> {
  public:
    VALUE convert(RoutineDataContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoutineDataContextProxy>(x, false, rb_cRoutineDataContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::CreateDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateDefinitionContext>(x, false, rb_cCreateDefinitionContext);
    }
  };

  template <>
  class To_Ruby<CreateDefinitionContextProxy*> {
  public:
    VALUE convert(CreateDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateDefinitionContextProxy>(x, false, rb_cCreateDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FullColumnNameContext*> {
  public:
    VALUE convert(MySqlParser::FullColumnNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FullColumnNameContext>(x, false, rb_cFullColumnNameContext);
    }
  };

  template <>
  class To_Ruby<FullColumnNameContextProxy*> {
  public:
    VALUE convert(FullColumnNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FullColumnNameContextProxy>(x, false, rb_cFullColumnNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ColumnDeclarationContext*> {
  public:
    VALUE convert(MySqlParser::ColumnDeclarationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ColumnDeclarationContext>(x, false, rb_cColumnDeclarationContext);
    }
  };

  template <>
  class To_Ruby<ColumnDeclarationContextProxy*> {
  public:
    VALUE convert(ColumnDeclarationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ColumnDeclarationContextProxy>(x, false, rb_cColumnDeclarationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ColumnDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::ColumnDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ColumnDefinitionContext>(x, false, rb_cColumnDefinitionContext);
    }
  };

  template <>
  class To_Ruby<ColumnDefinitionContextProxy*> {
  public:
    VALUE convert(ColumnDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ColumnDefinitionContextProxy>(x, false, rb_cColumnDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::TableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableConstraintContext>(x, false, rb_cTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<TableConstraintContextProxy*> {
  public:
    VALUE convert(TableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableConstraintContextProxy>(x, false, rb_cTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConstraintDeclarationContext*> {
  public:
    VALUE convert(MySqlParser::ConstraintDeclarationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConstraintDeclarationContext>(x, false, rb_cConstraintDeclarationContext);
    }
  };

  template <>
  class To_Ruby<ConstraintDeclarationContextProxy*> {
  public:
    VALUE convert(ConstraintDeclarationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConstraintDeclarationContextProxy>(x, false, rb_cConstraintDeclarationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexColumnDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::IndexColumnDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexColumnDefinitionContext>(x, false, rb_cIndexColumnDefinitionContext);
    }
  };

  template <>
  class To_Ruby<IndexColumnDefinitionContextProxy*> {
  public:
    VALUE convert(IndexColumnDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexColumnDefinitionContextProxy>(x, false, rb_cIndexColumnDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexDeclarationContext*> {
  public:
    VALUE convert(MySqlParser::IndexDeclarationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexDeclarationContext>(x, false, rb_cIndexDeclarationContext);
    }
  };

  template <>
  class To_Ruby<IndexDeclarationContextProxy*> {
  public:
    VALUE convert(IndexDeclarationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexDeclarationContextProxy>(x, false, rb_cIndexDeclarationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::ColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ColumnConstraintContext>(x, false, rb_cColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<ColumnConstraintContextProxy*> {
  public:
    VALUE convert(ColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ColumnConstraintContextProxy>(x, false, rb_cColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StorageColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::StorageColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StorageColumnConstraintContext>(x, false, rb_cStorageColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<StorageColumnConstraintContextProxy*> {
  public:
    VALUE convert(StorageColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StorageColumnConstraintContextProxy>(x, false, rb_cStorageColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::VisibilityColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::VisibilityColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::VisibilityColumnConstraintContext>(x, false, rb_cVisibilityColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<VisibilityColumnConstraintContextProxy*> {
  public:
    VALUE convert(VisibilityColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<VisibilityColumnConstraintContextProxy>(x, false, rb_cVisibilityColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AutoIncrementColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::AutoIncrementColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AutoIncrementColumnConstraintContext>(x, false, rb_cAutoIncrementColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<AutoIncrementColumnConstraintContextProxy*> {
  public:
    VALUE convert(AutoIncrementColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AutoIncrementColumnConstraintContextProxy>(x, false, rb_cAutoIncrementColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CurrentTimestampContext*> {
  public:
    VALUE convert(MySqlParser::CurrentTimestampContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CurrentTimestampContext>(x, false, rb_cCurrentTimestampContext);
    }
  };

  template <>
  class To_Ruby<CurrentTimestampContextProxy*> {
  public:
    VALUE convert(CurrentTimestampContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CurrentTimestampContextProxy>(x, false, rb_cCurrentTimestampContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CommentColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::CommentColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CommentColumnConstraintContext>(x, false, rb_cCommentColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<CommentColumnConstraintContextProxy*> {
  public:
    VALUE convert(CommentColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CommentColumnConstraintContextProxy>(x, false, rb_cCommentColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UniqueKeyColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::UniqueKeyColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UniqueKeyColumnConstraintContext>(x, false, rb_cUniqueKeyColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<UniqueKeyColumnConstraintContextProxy*> {
  public:
    VALUE convert(UniqueKeyColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UniqueKeyColumnConstraintContextProxy>(x, false, rb_cUniqueKeyColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SerialDefaultColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::SerialDefaultColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SerialDefaultColumnConstraintContext>(x, false, rb_cSerialDefaultColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<SerialDefaultColumnConstraintContextProxy*> {
  public:
    VALUE convert(SerialDefaultColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SerialDefaultColumnConstraintContextProxy>(x, false, rb_cSerialDefaultColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GeneratedColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::GeneratedColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GeneratedColumnConstraintContext>(x, false, rb_cGeneratedColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<GeneratedColumnConstraintContextProxy*> {
  public:
    VALUE convert(GeneratedColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GeneratedColumnConstraintContextProxy>(x, false, rb_cGeneratedColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FormatColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::FormatColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FormatColumnConstraintContext>(x, false, rb_cFormatColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<FormatColumnConstraintContextProxy*> {
  public:
    VALUE convert(FormatColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FormatColumnConstraintContextProxy>(x, false, rb_cFormatColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CollateColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::CollateColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CollateColumnConstraintContext>(x, false, rb_cCollateColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<CollateColumnConstraintContextProxy*> {
  public:
    VALUE convert(CollateColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CollateColumnConstraintContextProxy>(x, false, rb_cCollateColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrimaryKeyColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::PrimaryKeyColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrimaryKeyColumnConstraintContext>(x, false, rb_cPrimaryKeyColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<PrimaryKeyColumnConstraintContextProxy*> {
  public:
    VALUE convert(PrimaryKeyColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrimaryKeyColumnConstraintContextProxy>(x, false, rb_cPrimaryKeyColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CheckColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::CheckColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CheckColumnConstraintContext>(x, false, rb_cCheckColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<CheckColumnConstraintContextProxy*> {
  public:
    VALUE convert(CheckColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CheckColumnConstraintContextProxy>(x, false, rb_cCheckColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NullNotnullContext*> {
  public:
    VALUE convert(MySqlParser::NullNotnullContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NullNotnullContext>(x, false, rb_cNullNotnullContext);
    }
  };

  template <>
  class To_Ruby<NullNotnullContextProxy*> {
  public:
    VALUE convert(NullNotnullContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NullNotnullContextProxy>(x, false, rb_cNullNotnullContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NullColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::NullColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NullColumnConstraintContext>(x, false, rb_cNullColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<NullColumnConstraintContextProxy*> {
  public:
    VALUE convert(NullColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NullColumnConstraintContextProxy>(x, false, rb_cNullColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefaultColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::DefaultColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefaultColumnConstraintContext>(x, false, rb_cDefaultColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<DefaultColumnConstraintContextProxy*> {
  public:
    VALUE convert(DefaultColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefaultColumnConstraintContextProxy>(x, false, rb_cDefaultColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefaultValueContext*> {
  public:
    VALUE convert(MySqlParser::DefaultValueContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefaultValueContext>(x, false, rb_cDefaultValueContext);
    }
  };

  template <>
  class To_Ruby<DefaultValueContextProxy*> {
  public:
    VALUE convert(DefaultValueContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefaultValueContextProxy>(x, false, rb_cDefaultValueContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReferenceDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::ReferenceDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReferenceDefinitionContext>(x, false, rb_cReferenceDefinitionContext);
    }
  };

  template <>
  class To_Ruby<ReferenceDefinitionContextProxy*> {
  public:
    VALUE convert(ReferenceDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReferenceDefinitionContextProxy>(x, false, rb_cReferenceDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReferenceColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::ReferenceColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReferenceColumnConstraintContext>(x, false, rb_cReferenceColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<ReferenceColumnConstraintContextProxy*> {
  public:
    VALUE convert(ReferenceColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReferenceColumnConstraintContextProxy>(x, false, rb_cReferenceColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InvisibilityColumnConstraintContext*> {
  public:
    VALUE convert(MySqlParser::InvisibilityColumnConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InvisibilityColumnConstraintContext>(x, false, rb_cInvisibilityColumnConstraintContext);
    }
  };

  template <>
  class To_Ruby<InvisibilityColumnConstraintContextProxy*> {
  public:
    VALUE convert(InvisibilityColumnConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InvisibilityColumnConstraintContextProxy>(x, false, rb_cInvisibilityColumnConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UniqueKeyTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::UniqueKeyTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UniqueKeyTableConstraintContext>(x, false, rb_cUniqueKeyTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<UniqueKeyTableConstraintContextProxy*> {
  public:
    VALUE convert(UniqueKeyTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UniqueKeyTableConstraintContextProxy>(x, false, rb_cUniqueKeyTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CheckTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::CheckTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CheckTableConstraintContext>(x, false, rb_cCheckTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<CheckTableConstraintContextProxy*> {
  public:
    VALUE convert(CheckTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CheckTableConstraintContextProxy>(x, false, rb_cCheckTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrimaryKeyTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::PrimaryKeyTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrimaryKeyTableConstraintContext>(x, false, rb_cPrimaryKeyTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<PrimaryKeyTableConstraintContextProxy*> {
  public:
    VALUE convert(PrimaryKeyTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrimaryKeyTableConstraintContextProxy>(x, false, rb_cPrimaryKeyTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ForeignKeyTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::ForeignKeyTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ForeignKeyTableConstraintContext>(x, false, rb_cForeignKeyTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<ForeignKeyTableConstraintContextProxy*> {
  public:
    VALUE convert(ForeignKeyTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ForeignKeyTableConstraintContextProxy>(x, false, rb_cForeignKeyTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReferenceActionContext*> {
  public:
    VALUE convert(MySqlParser::ReferenceActionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReferenceActionContext>(x, false, rb_cReferenceActionContext);
    }
  };

  template <>
  class To_Ruby<ReferenceActionContextProxy*> {
  public:
    VALUE convert(ReferenceActionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReferenceActionContextProxy>(x, false, rb_cReferenceActionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReferenceControlTypeContext*> {
  public:
    VALUE convert(MySqlParser::ReferenceControlTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReferenceControlTypeContext>(x, false, rb_cReferenceControlTypeContext);
    }
  };

  template <>
  class To_Ruby<ReferenceControlTypeContextProxy*> {
  public:
    VALUE convert(ReferenceControlTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReferenceControlTypeContextProxy>(x, false, rb_cReferenceControlTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SpecialIndexDeclarationContext*> {
  public:
    VALUE convert(MySqlParser::SpecialIndexDeclarationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SpecialIndexDeclarationContext>(x, false, rb_cSpecialIndexDeclarationContext);
    }
  };

  template <>
  class To_Ruby<SpecialIndexDeclarationContextProxy*> {
  public:
    VALUE convert(SpecialIndexDeclarationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SpecialIndexDeclarationContextProxy>(x, false, rb_cSpecialIndexDeclarationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleIndexDeclarationContext*> {
  public:
    VALUE convert(MySqlParser::SimpleIndexDeclarationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleIndexDeclarationContext>(x, false, rb_cSimpleIndexDeclarationContext);
    }
  };

  template <>
  class To_Ruby<SimpleIndexDeclarationContextProxy*> {
  public:
    VALUE convert(SimpleIndexDeclarationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleIndexDeclarationContextProxy>(x, false, rb_cSimpleIndexDeclarationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionEngineContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionEngineContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionEngineContext>(x, false, rb_cTableOptionEngineContext);
    }
  };

  template <>
  class To_Ruby<TableOptionEngineContextProxy*> {
  public:
    VALUE convert(TableOptionEngineContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionEngineContextProxy>(x, false, rb_cTableOptionEngineContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionMaxRowsContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionMaxRowsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionMaxRowsContext>(x, false, rb_cTableOptionMaxRowsContext);
    }
  };

  template <>
  class To_Ruby<TableOptionMaxRowsContextProxy*> {
  public:
    VALUE convert(TableOptionMaxRowsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionMaxRowsContextProxy>(x, false, rb_cTableOptionMaxRowsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionCollateContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionCollateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionCollateContext>(x, false, rb_cTableOptionCollateContext);
    }
  };

  template <>
  class To_Ruby<TableOptionCollateContextProxy*> {
  public:
    VALUE convert(TableOptionCollateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionCollateContextProxy>(x, false, rb_cTableOptionCollateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionPersistentContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionPersistentContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionPersistentContext>(x, false, rb_cTableOptionPersistentContext);
    }
  };

  template <>
  class To_Ruby<TableOptionPersistentContextProxy*> {
  public:
    VALUE convert(TableOptionPersistentContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionPersistentContextProxy>(x, false, rb_cTableOptionPersistentContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionTablespaceContext>(x, false, rb_cTableOptionTablespaceContext);
    }
  };

  template <>
  class To_Ruby<TableOptionTablespaceContextProxy*> {
  public:
    VALUE convert(TableOptionTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionTablespaceContextProxy>(x, false, rb_cTableOptionTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TablespaceStorageContext*> {
  public:
    VALUE convert(MySqlParser::TablespaceStorageContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TablespaceStorageContext>(x, false, rb_cTablespaceStorageContext);
    }
  };

  template <>
  class To_Ruby<TablespaceStorageContextProxy*> {
  public:
    VALUE convert(TablespaceStorageContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TablespaceStorageContextProxy>(x, false, rb_cTablespaceStorageContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionAutoextendSizeContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionAutoextendSizeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionAutoextendSizeContext>(x, false, rb_cTableOptionAutoextendSizeContext);
    }
  };

  template <>
  class To_Ruby<TableOptionAutoextendSizeContextProxy*> {
  public:
    VALUE convert(TableOptionAutoextendSizeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionAutoextendSizeContextProxy>(x, false, rb_cTableOptionAutoextendSizeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionPageCompressedContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionPageCompressedContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionPageCompressedContext>(x, false, rb_cTableOptionPageCompressedContext);
    }
  };

  template <>
  class To_Ruby<TableOptionPageCompressedContextProxy*> {
  public:
    VALUE convert(TableOptionPageCompressedContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionPageCompressedContextProxy>(x, false, rb_cTableOptionPageCompressedContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionStartTransactionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionStartTransactionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionStartTransactionContext>(x, false, rb_cTableOptionStartTransactionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionStartTransactionContextProxy*> {
  public:
    VALUE convert(TableOptionStartTransactionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionStartTransactionContextProxy>(x, false, rb_cTableOptionStartTransactionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionPackKeysContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionPackKeysContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionPackKeysContext>(x, false, rb_cTableOptionPackKeysContext);
    }
  };

  template <>
  class To_Ruby<TableOptionPackKeysContextProxy*> {
  public:
    VALUE convert(TableOptionPackKeysContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionPackKeysContextProxy>(x, false, rb_cTableOptionPackKeysContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionPasswordContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionPasswordContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionPasswordContext>(x, false, rb_cTableOptionPasswordContext);
    }
  };

  template <>
  class To_Ruby<TableOptionPasswordContextProxy*> {
  public:
    VALUE convert(TableOptionPasswordContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionPasswordContextProxy>(x, false, rb_cTableOptionPasswordContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionUnionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionUnionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionUnionContext>(x, false, rb_cTableOptionUnionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionUnionContextProxy*> {
  public:
    VALUE convert(TableOptionUnionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionUnionContextProxy>(x, false, rb_cTableOptionUnionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TablesContext*> {
  public:
    VALUE convert(MySqlParser::TablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TablesContext>(x, false, rb_cTablesContext);
    }
  };

  template <>
  class To_Ruby<TablesContextProxy*> {
  public:
    VALUE convert(TablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TablesContextProxy>(x, false, rb_cTablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionSamplePageContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionSamplePageContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionSamplePageContext>(x, false, rb_cTableOptionSamplePageContext);
    }
  };

  template <>
  class To_Ruby<TableOptionSamplePageContextProxy*> {
  public:
    VALUE convert(TableOptionSamplePageContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionSamplePageContextProxy>(x, false, rb_cTableOptionSamplePageContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionCharsetContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionCharsetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionCharsetContext>(x, false, rb_cTableOptionCharsetContext);
    }
  };

  template <>
  class To_Ruby<TableOptionCharsetContextProxy*> {
  public:
    VALUE convert(TableOptionCharsetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionCharsetContextProxy>(x, false, rb_cTableOptionCharsetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionIndexDirectoryContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionIndexDirectoryContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionIndexDirectoryContext>(x, false, rb_cTableOptionIndexDirectoryContext);
    }
  };

  template <>
  class To_Ruby<TableOptionIndexDirectoryContextProxy*> {
  public:
    VALUE convert(TableOptionIndexDirectoryContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionIndexDirectoryContextProxy>(x, false, rb_cTableOptionIndexDirectoryContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionTableTypeContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionTableTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionTableTypeContext>(x, false, rb_cTableOptionTableTypeContext);
    }
  };

  template <>
  class To_Ruby<TableOptionTableTypeContextProxy*> {
  public:
    VALUE convert(TableOptionTableTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionTableTypeContextProxy>(x, false, rb_cTableOptionTableTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableTypeContext*> {
  public:
    VALUE convert(MySqlParser::TableTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableTypeContext>(x, false, rb_cTableTypeContext);
    }
  };

  template <>
  class To_Ruby<TableTypeContextProxy*> {
  public:
    VALUE convert(TableTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableTypeContextProxy>(x, false, rb_cTableTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionKeyBlockSizeContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionKeyBlockSizeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionKeyBlockSizeContext>(x, false, rb_cTableOptionKeyBlockSizeContext);
    }
  };

  template <>
  class To_Ruby<TableOptionKeyBlockSizeContextProxy*> {
  public:
    VALUE convert(TableOptionKeyBlockSizeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionKeyBlockSizeContextProxy>(x, false, rb_cTableOptionKeyBlockSizeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionEncryptionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionEncryptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionEncryptionContext>(x, false, rb_cTableOptionEncryptionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionEncryptionContextProxy*> {
  public:
    VALUE convert(TableOptionEncryptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionEncryptionContextProxy>(x, false, rb_cTableOptionEncryptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionDataDirectoryContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionDataDirectoryContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionDataDirectoryContext>(x, false, rb_cTableOptionDataDirectoryContext);
    }
  };

  template <>
  class To_Ruby<TableOptionDataDirectoryContextProxy*> {
  public:
    VALUE convert(TableOptionDataDirectoryContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionDataDirectoryContextProxy>(x, false, rb_cTableOptionDataDirectoryContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionRecalculationContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionRecalculationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionRecalculationContext>(x, false, rb_cTableOptionRecalculationContext);
    }
  };

  template <>
  class To_Ruby<TableOptionRecalculationContextProxy*> {
  public:
    VALUE convert(TableOptionRecalculationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionRecalculationContextProxy>(x, false, rb_cTableOptionRecalculationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionAutoIncrementContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionAutoIncrementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionAutoIncrementContext>(x, false, rb_cTableOptionAutoIncrementContext);
    }
  };

  template <>
  class To_Ruby<TableOptionAutoIncrementContextProxy*> {
  public:
    VALUE convert(TableOptionAutoIncrementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionAutoIncrementContextProxy>(x, false, rb_cTableOptionAutoIncrementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionEncryptionKeyIdContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionEncryptionKeyIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionEncryptionKeyIdContext>(x, false, rb_cTableOptionEncryptionKeyIdContext);
    }
  };

  template <>
  class To_Ruby<TableOptionEncryptionKeyIdContextProxy*> {
  public:
    VALUE convert(TableOptionEncryptionKeyIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionEncryptionKeyIdContextProxy>(x, false, rb_cTableOptionEncryptionKeyIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionChecksumContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionChecksumContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionChecksumContext>(x, false, rb_cTableOptionChecksumContext);
    }
  };

  template <>
  class To_Ruby<TableOptionChecksumContextProxy*> {
  public:
    VALUE convert(TableOptionChecksumContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionChecksumContextProxy>(x, false, rb_cTableOptionChecksumContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionDelayContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionDelayContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionDelayContext>(x, false, rb_cTableOptionDelayContext);
    }
  };

  template <>
  class To_Ruby<TableOptionDelayContextProxy*> {
  public:
    VALUE convert(TableOptionDelayContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionDelayContextProxy>(x, false, rb_cTableOptionDelayContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionConnectionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionConnectionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionConnectionContext>(x, false, rb_cTableOptionConnectionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionConnectionContextProxy*> {
  public:
    VALUE convert(TableOptionConnectionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionConnectionContextProxy>(x, false, rb_cTableOptionConnectionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionTransactionalContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionTransactionalContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionTransactionalContext>(x, false, rb_cTableOptionTransactionalContext);
    }
  };

  template <>
  class To_Ruby<TableOptionTransactionalContextProxy*> {
  public:
    VALUE convert(TableOptionTransactionalContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionTransactionalContextProxy>(x, false, rb_cTableOptionTransactionalContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionPageCompressionLevelContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionPageCompressionLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionPageCompressionLevelContext>(x, false, rb_cTableOptionPageCompressionLevelContext);
    }
  };

  template <>
  class To_Ruby<TableOptionPageCompressionLevelContextProxy*> {
  public:
    VALUE convert(TableOptionPageCompressionLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionPageCompressionLevelContextProxy>(x, false, rb_cTableOptionPageCompressionLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionSecondaryEngineAttributeContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionSecondaryEngineAttributeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionSecondaryEngineAttributeContext>(x, false, rb_cTableOptionSecondaryEngineAttributeContext);
    }
  };

  template <>
  class To_Ruby<TableOptionSecondaryEngineAttributeContextProxy*> {
  public:
    VALUE convert(TableOptionSecondaryEngineAttributeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionSecondaryEngineAttributeContextProxy>(x, false, rb_cTableOptionSecondaryEngineAttributeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionCommentContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionCommentContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionCommentContext>(x, false, rb_cTableOptionCommentContext);
    }
  };

  template <>
  class To_Ruby<TableOptionCommentContextProxy*> {
  public:
    VALUE convert(TableOptionCommentContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionCommentContextProxy>(x, false, rb_cTableOptionCommentContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionAverageContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionAverageContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionAverageContext>(x, false, rb_cTableOptionAverageContext);
    }
  };

  template <>
  class To_Ruby<TableOptionAverageContextProxy*> {
  public:
    VALUE convert(TableOptionAverageContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionAverageContextProxy>(x, false, rb_cTableOptionAverageContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionRowFormatContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionRowFormatContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionRowFormatContext>(x, false, rb_cTableOptionRowFormatContext);
    }
  };

  template <>
  class To_Ruby<TableOptionRowFormatContextProxy*> {
  public:
    VALUE convert(TableOptionRowFormatContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionRowFormatContextProxy>(x, false, rb_cTableOptionRowFormatContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionCompressionContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionCompressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionCompressionContext>(x, false, rb_cTableOptionCompressionContext);
    }
  };

  template <>
  class To_Ruby<TableOptionCompressionContextProxy*> {
  public:
    VALUE convert(TableOptionCompressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionCompressionContextProxy>(x, false, rb_cTableOptionCompressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionInsertMethodContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionInsertMethodContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionInsertMethodContext>(x, false, rb_cTableOptionInsertMethodContext);
    }
  };

  template <>
  class To_Ruby<TableOptionInsertMethodContextProxy*> {
  public:
    VALUE convert(TableOptionInsertMethodContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionInsertMethodContextProxy>(x, false, rb_cTableOptionInsertMethodContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionEngineAttributeContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionEngineAttributeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionEngineAttributeContext>(x, false, rb_cTableOptionEngineAttributeContext);
    }
  };

  template <>
  class To_Ruby<TableOptionEngineAttributeContextProxy*> {
  public:
    VALUE convert(TableOptionEngineAttributeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionEngineAttributeContextProxy>(x, false, rb_cTableOptionEngineAttributeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableOptionMinRowsContext*> {
  public:
    VALUE convert(MySqlParser::TableOptionMinRowsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableOptionMinRowsContext>(x, false, rb_cTableOptionMinRowsContext);
    }
  };

  template <>
  class To_Ruby<TableOptionMinRowsContextProxy*> {
  public:
    VALUE convert(TableOptionMinRowsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableOptionMinRowsContextProxy>(x, false, rb_cTableOptionMinRowsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionFunctionDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::PartitionFunctionDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionFunctionDefinitionContext>(x, false, rb_cPartitionFunctionDefinitionContext);
    }
  };

  template <>
  class To_Ruby<PartitionFunctionDefinitionContextProxy*> {
  public:
    VALUE convert(PartitionFunctionDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionFunctionDefinitionContextProxy>(x, false, rb_cPartitionFunctionDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubpartitionFunctionDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::SubpartitionFunctionDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubpartitionFunctionDefinitionContext>(x, false, rb_cSubpartitionFunctionDefinitionContext);
    }
  };

  template <>
  class To_Ruby<SubpartitionFunctionDefinitionContextProxy*> {
  public:
    VALUE convert(SubpartitionFunctionDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubpartitionFunctionDefinitionContextProxy>(x, false, rb_cSubpartitionFunctionDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::PartitionDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionDefinitionContext>(x, false, rb_cPartitionDefinitionContext);
    }
  };

  template <>
  class To_Ruby<PartitionDefinitionContextProxy*> {
  public:
    VALUE convert(PartitionDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionDefinitionContextProxy>(x, false, rb_cPartitionDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionFunctionKeyContext*> {
  public:
    VALUE convert(MySqlParser::PartitionFunctionKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionFunctionKeyContext>(x, false, rb_cPartitionFunctionKeyContext);
    }
  };

  template <>
  class To_Ruby<PartitionFunctionKeyContextProxy*> {
  public:
    VALUE convert(PartitionFunctionKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionFunctionKeyContextProxy>(x, false, rb_cPartitionFunctionKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionFunctionHashContext*> {
  public:
    VALUE convert(MySqlParser::PartitionFunctionHashContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionFunctionHashContext>(x, false, rb_cPartitionFunctionHashContext);
    }
  };

  template <>
  class To_Ruby<PartitionFunctionHashContextProxy*> {
  public:
    VALUE convert(PartitionFunctionHashContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionFunctionHashContextProxy>(x, false, rb_cPartitionFunctionHashContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionFunctionListContext*> {
  public:
    VALUE convert(MySqlParser::PartitionFunctionListContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionFunctionListContext>(x, false, rb_cPartitionFunctionListContext);
    }
  };

  template <>
  class To_Ruby<PartitionFunctionListContextProxy*> {
  public:
    VALUE convert(PartitionFunctionListContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionFunctionListContextProxy>(x, false, rb_cPartitionFunctionListContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionFunctionRangeContext*> {
  public:
    VALUE convert(MySqlParser::PartitionFunctionRangeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionFunctionRangeContext>(x, false, rb_cPartitionFunctionRangeContext);
    }
  };

  template <>
  class To_Ruby<PartitionFunctionRangeContextProxy*> {
  public:
    VALUE convert(PartitionFunctionRangeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionFunctionRangeContextProxy>(x, false, rb_cPartitionFunctionRangeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubPartitionFunctionHashContext*> {
  public:
    VALUE convert(MySqlParser::SubPartitionFunctionHashContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubPartitionFunctionHashContext>(x, false, rb_cSubPartitionFunctionHashContext);
    }
  };

  template <>
  class To_Ruby<SubPartitionFunctionHashContextProxy*> {
  public:
    VALUE convert(SubPartitionFunctionHashContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubPartitionFunctionHashContextProxy>(x, false, rb_cSubPartitionFunctionHashContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubPartitionFunctionKeyContext*> {
  public:
    VALUE convert(MySqlParser::SubPartitionFunctionKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubPartitionFunctionKeyContext>(x, false, rb_cSubPartitionFunctionKeyContext);
    }
  };

  template <>
  class To_Ruby<SubPartitionFunctionKeyContextProxy*> {
  public:
    VALUE convert(SubPartitionFunctionKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubPartitionFunctionKeyContextProxy>(x, false, rb_cSubPartitionFunctionKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionComparisonContext*> {
  public:
    VALUE convert(MySqlParser::PartitionComparisonContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionComparisonContext>(x, false, rb_cPartitionComparisonContext);
    }
  };

  template <>
  class To_Ruby<PartitionComparisonContextProxy*> {
  public:
    VALUE convert(PartitionComparisonContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionComparisonContextProxy>(x, false, rb_cPartitionComparisonContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionDefinerAtomContext*> {
  public:
    VALUE convert(MySqlParser::PartitionDefinerAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionDefinerAtomContext>(x, false, rb_cPartitionDefinerAtomContext);
    }
  };

  template <>
  class To_Ruby<PartitionDefinerAtomContextProxy*> {
  public:
    VALUE convert(PartitionDefinerAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionDefinerAtomContextProxy>(x, false, rb_cPartitionDefinerAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionContext>(x, false, rb_cPartitionOptionContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionContextProxy*> {
  public:
    VALUE convert(PartitionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionContextProxy>(x, false, rb_cPartitionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubpartitionDefinitionContext*> {
  public:
    VALUE convert(MySqlParser::SubpartitionDefinitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubpartitionDefinitionContext>(x, false, rb_cSubpartitionDefinitionContext);
    }
  };

  template <>
  class To_Ruby<SubpartitionDefinitionContextProxy*> {
  public:
    VALUE convert(SubpartitionDefinitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubpartitionDefinitionContextProxy>(x, false, rb_cSubpartitionDefinitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionListAtomContext*> {
  public:
    VALUE convert(MySqlParser::PartitionListAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionListAtomContext>(x, false, rb_cPartitionListAtomContext);
    }
  };

  template <>
  class To_Ruby<PartitionListAtomContextProxy*> {
  public:
    VALUE convert(PartitionListAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionListAtomContextProxy>(x, false, rb_cPartitionListAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionListVectorContext*> {
  public:
    VALUE convert(MySqlParser::PartitionListVectorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionListVectorContext>(x, false, rb_cPartitionListVectorContext);
    }
  };

  template <>
  class To_Ruby<PartitionListVectorContextProxy*> {
  public:
    VALUE convert(PartitionListVectorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionListVectorContextProxy>(x, false, rb_cPartitionListVectorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionDefinerVectorContext*> {
  public:
    VALUE convert(MySqlParser::PartitionDefinerVectorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionDefinerVectorContext>(x, false, rb_cPartitionDefinerVectorContext);
    }
  };

  template <>
  class To_Ruby<PartitionDefinerVectorContextProxy*> {
  public:
    VALUE convert(PartitionDefinerVectorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionDefinerVectorContextProxy>(x, false, rb_cPartitionDefinerVectorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionSimpleContext*> {
  public:
    VALUE convert(MySqlParser::PartitionSimpleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionSimpleContext>(x, false, rb_cPartitionSimpleContext);
    }
  };

  template <>
  class To_Ruby<PartitionSimpleContextProxy*> {
  public:
    VALUE convert(PartitionSimpleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionSimpleContextProxy>(x, false, rb_cPartitionSimpleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConstantContext*> {
  public:
    VALUE convert(MySqlParser::ConstantContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConstantContext>(x, false, rb_cConstantContext);
    }
  };

  template <>
  class To_Ruby<ConstantContextProxy*> {
  public:
    VALUE convert(ConstantContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConstantContextProxy>(x, false, rb_cConstantContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionCommentContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionCommentContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionCommentContext>(x, false, rb_cPartitionOptionCommentContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionCommentContextProxy*> {
  public:
    VALUE convert(PartitionOptionCommentContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionCommentContextProxy>(x, false, rb_cPartitionOptionCommentContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionNodeGroupContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionNodeGroupContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionNodeGroupContext>(x, false, rb_cPartitionOptionNodeGroupContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionNodeGroupContextProxy*> {
  public:
    VALUE convert(PartitionOptionNodeGroupContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionNodeGroupContextProxy>(x, false, rb_cPartitionOptionNodeGroupContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionIndexDirectoryContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionIndexDirectoryContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionIndexDirectoryContext>(x, false, rb_cPartitionOptionIndexDirectoryContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionIndexDirectoryContextProxy*> {
  public:
    VALUE convert(PartitionOptionIndexDirectoryContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionIndexDirectoryContextProxy>(x, false, rb_cPartitionOptionIndexDirectoryContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionMaxRowsContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionMaxRowsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionMaxRowsContext>(x, false, rb_cPartitionOptionMaxRowsContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionMaxRowsContextProxy*> {
  public:
    VALUE convert(PartitionOptionMaxRowsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionMaxRowsContextProxy>(x, false, rb_cPartitionOptionMaxRowsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionTablespaceContext>(x, false, rb_cPartitionOptionTablespaceContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionTablespaceContextProxy*> {
  public:
    VALUE convert(PartitionOptionTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionTablespaceContextProxy>(x, false, rb_cPartitionOptionTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionEngineContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionEngineContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionEngineContext>(x, false, rb_cPartitionOptionEngineContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionEngineContextProxy*> {
  public:
    VALUE convert(PartitionOptionEngineContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionEngineContextProxy>(x, false, rb_cPartitionOptionEngineContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionMinRowsContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionMinRowsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionMinRowsContext>(x, false, rb_cPartitionOptionMinRowsContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionMinRowsContextProxy*> {
  public:
    VALUE convert(PartitionOptionMinRowsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionMinRowsContextProxy>(x, false, rb_cPartitionOptionMinRowsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionOptionDataDirectoryContext*> {
  public:
    VALUE convert(MySqlParser::PartitionOptionDataDirectoryContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionOptionDataDirectoryContext>(x, false, rb_cPartitionOptionDataDirectoryContext);
    }
  };

  template <>
  class To_Ruby<PartitionOptionDataDirectoryContextProxy*> {
  public:
    VALUE convert(PartitionOptionDataDirectoryContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionOptionDataDirectoryContextProxy>(x, false, rb_cPartitionOptionDataDirectoryContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterUpgradeNameContext*> {
  public:
    VALUE convert(MySqlParser::AlterUpgradeNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterUpgradeNameContext>(x, false, rb_cAlterUpgradeNameContext);
    }
  };

  template <>
  class To_Ruby<AlterUpgradeNameContextProxy*> {
  public:
    VALUE convert(AlterUpgradeNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterUpgradeNameContextProxy>(x, false, rb_cAlterUpgradeNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterSimpleDatabaseContext*> {
  public:
    VALUE convert(MySqlParser::AlterSimpleDatabaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterSimpleDatabaseContext>(x, false, rb_cAlterSimpleDatabaseContext);
    }
  };

  template <>
  class To_Ruby<AlterSimpleDatabaseContextProxy*> {
  public:
    VALUE convert(AlterSimpleDatabaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterSimpleDatabaseContextProxy>(x, false, rb_cAlterSimpleDatabaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WaitNowaitClauseContext*> {
  public:
    VALUE convert(MySqlParser::WaitNowaitClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WaitNowaitClauseContext>(x, false, rb_cWaitNowaitClauseContext);
    }
  };

  template <>
  class To_Ruby<WaitNowaitClauseContextProxy*> {
  public:
    VALUE convert(WaitNowaitClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WaitNowaitClauseContextProxy>(x, false, rb_cWaitNowaitClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterSpecificationContext*> {
  public:
    VALUE convert(MySqlParser::AlterSpecificationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterSpecificationContext>(x, false, rb_cAlterSpecificationContext);
    }
  };

  template <>
  class To_Ruby<AlterSpecificationContextProxy*> {
  public:
    VALUE convert(AlterSpecificationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterSpecificationContextProxy>(x, false, rb_cAlterSpecificationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAlterColumnDefaultContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAlterColumnDefaultContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAlterColumnDefaultContext>(x, false, rb_cAlterByAlterColumnDefaultContext);
    }
  };

  template <>
  class To_Ruby<AlterByAlterColumnDefaultContextProxy*> {
  public:
    VALUE convert(AlterByAlterColumnDefaultContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAlterColumnDefaultContextProxy>(x, false, rb_cAlterByAlterColumnDefaultContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDisableKeysContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDisableKeysContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDisableKeysContext>(x, false, rb_cAlterByDisableKeysContext);
    }
  };

  template <>
  class To_Ruby<AlterByDisableKeysContextProxy*> {
  public:
    VALUE convert(AlterByDisableKeysContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDisableKeysContextProxy>(x, false, rb_cAlterByDisableKeysContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDefaultCharsetContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDefaultCharsetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDefaultCharsetContext>(x, false, rb_cAlterByDefaultCharsetContext);
    }
  };

  template <>
  class To_Ruby<AlterByDefaultCharsetContextProxy*> {
  public:
    VALUE convert(AlterByDefaultCharsetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDefaultCharsetContextProxy>(x, false, rb_cAlterByDefaultCharsetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRenameColumnContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRenameColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRenameColumnContext>(x, false, rb_cAlterByRenameColumnContext);
    }
  };

  template <>
  class To_Ruby<AlterByRenameColumnContextProxy*> {
  public:
    VALUE convert(AlterByRenameColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRenameColumnContextProxy>(x, false, rb_cAlterByRenameColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByConvertCharsetContext*> {
  public:
    VALUE convert(MySqlParser::AlterByConvertCharsetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByConvertCharsetContext>(x, false, rb_cAlterByConvertCharsetContext);
    }
  };

  template <>
  class To_Ruby<AlterByConvertCharsetContextProxy*> {
  public:
    VALUE convert(AlterByConvertCharsetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByConvertCharsetContextProxy>(x, false, rb_cAlterByConvertCharsetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddForeignKeyContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddForeignKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddForeignKeyContext>(x, false, rb_cAlterByAddForeignKeyContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddForeignKeyContextProxy*> {
  public:
    VALUE convert(AlterByAddForeignKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddForeignKeyContextProxy>(x, false, rb_cAlterByAddForeignKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRenameIndexContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRenameIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRenameIndexContext>(x, false, rb_cAlterByRenameIndexContext);
    }
  };

  template <>
  class To_Ruby<AlterByRenameIndexContextProxy*> {
  public:
    VALUE convert(AlterByRenameIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRenameIndexContextProxy>(x, false, rb_cAlterByRenameIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRenameContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRenameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRenameContext>(x, false, rb_cAlterByRenameContext);
    }
  };

  template <>
  class To_Ruby<AlterByRenameContextProxy*> {
  public:
    VALUE convert(AlterByRenameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRenameContextProxy>(x, false, rb_cAlterByRenameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByImportTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::AlterByImportTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByImportTablespaceContext>(x, false, rb_cAlterByImportTablespaceContext);
    }
  };

  template <>
  class To_Ruby<AlterByImportTablespaceContextProxy*> {
  public:
    VALUE convert(AlterByImportTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByImportTablespaceContextProxy>(x, false, rb_cAlterByImportTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddDefinitionsContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddDefinitionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddDefinitionsContext>(x, false, rb_cAlterByAddDefinitionsContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddDefinitionsContextProxy*> {
  public:
    VALUE convert(AlterByAddDefinitionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddDefinitionsContextProxy>(x, false, rb_cAlterByAddDefinitionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAlterCheckTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAlterCheckTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAlterCheckTableConstraintContext>(x, false, rb_cAlterByAlterCheckTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<AlterByAlterCheckTableConstraintContextProxy*> {
  public:
    VALUE convert(AlterByAlterCheckTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAlterCheckTableConstraintContextProxy>(x, false, rb_cAlterByAlterCheckTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropConstraintCheckContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropConstraintCheckContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropConstraintCheckContext>(x, false, rb_cAlterByDropConstraintCheckContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropConstraintCheckContextProxy*> {
  public:
    VALUE convert(AlterByDropConstraintCheckContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropConstraintCheckContextProxy>(x, false, rb_cAlterByDropConstraintCheckContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddColumnsContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddColumnsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddColumnsContext>(x, false, rb_cAlterByAddColumnsContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddColumnsContextProxy*> {
  public:
    VALUE convert(AlterByAddColumnsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddColumnsContextProxy>(x, false, rb_cAlterByAddColumnsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAlterIndexVisibilityContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAlterIndexVisibilityContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAlterIndexVisibilityContext>(x, false, rb_cAlterByAlterIndexVisibilityContext);
    }
  };

  template <>
  class To_Ruby<AlterByAlterIndexVisibilityContextProxy*> {
  public:
    VALUE convert(AlterByAlterIndexVisibilityContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAlterIndexVisibilityContextProxy>(x, false, rb_cAlterByAlterIndexVisibilityContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropForeignKeyContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropForeignKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropForeignKeyContext>(x, false, rb_cAlterByDropForeignKeyContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropForeignKeyContextProxy*> {
  public:
    VALUE convert(AlterByDropForeignKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropForeignKeyContextProxy>(x, false, rb_cAlterByDropForeignKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddCheckTableConstraintContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddCheckTableConstraintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddCheckTableConstraintContext>(x, false, rb_cAlterByAddCheckTableConstraintContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddCheckTableConstraintContextProxy*> {
  public:
    VALUE convert(AlterByAddCheckTableConstraintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddCheckTableConstraintContextProxy>(x, false, rb_cAlterByAddCheckTableConstraintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterPartitionSpecificationContext*> {
  public:
    VALUE convert(MySqlParser::AlterPartitionSpecificationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterPartitionSpecificationContext>(x, false, rb_cAlterPartitionSpecificationContext);
    }
  };

  template <>
  class To_Ruby<AlterPartitionSpecificationContextProxy*> {
  public:
    VALUE convert(AlterPartitionSpecificationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterPartitionSpecificationContextProxy>(x, false, rb_cAlterPartitionSpecificationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterPartitionContext>(x, false, rb_cAlterPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterPartitionContextProxy*> {
  public:
    VALUE convert(AlterPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterPartitionContextProxy>(x, false, rb_cAlterPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddIndexContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddIndexContext>(x, false, rb_cAlterByAddIndexContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddIndexContextProxy*> {
  public:
    VALUE convert(AlterByAddIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddIndexContextProxy>(x, false, rb_cAlterByAddIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropColumnContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropColumnContext>(x, false, rb_cAlterByDropColumnContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropColumnContextProxy*> {
  public:
    VALUE convert(AlterByDropColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropColumnContextProxy>(x, false, rb_cAlterByDropColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByChangeDefaultContext*> {
  public:
    VALUE convert(MySqlParser::AlterByChangeDefaultContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByChangeDefaultContext>(x, false, rb_cAlterByChangeDefaultContext);
    }
  };

  template <>
  class To_Ruby<AlterByChangeDefaultContextProxy*> {
  public:
    VALUE convert(AlterByChangeDefaultContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByChangeDefaultContextProxy>(x, false, rb_cAlterByChangeDefaultContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByForceContext*> {
  public:
    VALUE convert(MySqlParser::AlterByForceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByForceContext>(x, false, rb_cAlterByForceContext);
    }
  };

  template <>
  class To_Ruby<AlterByForceContextProxy*> {
  public:
    VALUE convert(AlterByForceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByForceContextProxy>(x, false, rb_cAlterByForceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddSpecialIndexContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddSpecialIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddSpecialIndexContext>(x, false, rb_cAlterByAddSpecialIndexContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddSpecialIndexContextProxy*> {
  public:
    VALUE convert(AlterByAddSpecialIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddSpecialIndexContextProxy>(x, false, rb_cAlterByAddSpecialIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByModifyColumnContext*> {
  public:
    VALUE convert(MySqlParser::AlterByModifyColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByModifyColumnContext>(x, false, rb_cAlterByModifyColumnContext);
    }
  };

  template <>
  class To_Ruby<AlterByModifyColumnContextProxy*> {
  public:
    VALUE convert(AlterByModifyColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByModifyColumnContextProxy>(x, false, rb_cAlterByModifyColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByTableOptionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByTableOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByTableOptionContext>(x, false, rb_cAlterByTableOptionContext);
    }
  };

  template <>
  class To_Ruby<AlterByTableOptionContextProxy*> {
  public:
    VALUE convert(AlterByTableOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByTableOptionContextProxy>(x, false, rb_cAlterByTableOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropPrimaryKeyContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropPrimaryKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropPrimaryKeyContext>(x, false, rb_cAlterByDropPrimaryKeyContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropPrimaryKeyContextProxy*> {
  public:
    VALUE convert(AlterByDropPrimaryKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropPrimaryKeyContextProxy>(x, false, rb_cAlterByDropPrimaryKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByLockContext*> {
  public:
    VALUE convert(MySqlParser::AlterByLockContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByLockContext>(x, false, rb_cAlterByLockContext);
    }
  };

  template <>
  class To_Ruby<AlterByLockContextProxy*> {
  public:
    VALUE convert(AlterByLockContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByLockContextProxy>(x, false, rb_cAlterByLockContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDiscardTablespaceContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDiscardTablespaceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDiscardTablespaceContext>(x, false, rb_cAlterByDiscardTablespaceContext);
    }
  };

  template <>
  class To_Ruby<AlterByDiscardTablespaceContextProxy*> {
  public:
    VALUE convert(AlterByDiscardTablespaceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDiscardTablespaceContextProxy>(x, false, rb_cAlterByDiscardTablespaceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByValidateContext*> {
  public:
    VALUE convert(MySqlParser::AlterByValidateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByValidateContext>(x, false, rb_cAlterByValidateContext);
    }
  };

  template <>
  class To_Ruby<AlterByValidateContextProxy*> {
  public:
    VALUE convert(AlterByValidateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByValidateContextProxy>(x, false, rb_cAlterByValidateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddPrimaryKeyContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddPrimaryKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddPrimaryKeyContext>(x, false, rb_cAlterByAddPrimaryKeyContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddPrimaryKeyContextProxy*> {
  public:
    VALUE convert(AlterByAddPrimaryKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddPrimaryKeyContextProxy>(x, false, rb_cAlterByAddPrimaryKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByEnableKeysContext*> {
  public:
    VALUE convert(MySqlParser::AlterByEnableKeysContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByEnableKeysContext>(x, false, rb_cAlterByEnableKeysContext);
    }
  };

  template <>
  class To_Ruby<AlterByEnableKeysContextProxy*> {
  public:
    VALUE convert(AlterByEnableKeysContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByEnableKeysContextProxy>(x, false, rb_cAlterByEnableKeysContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterBySetAlgorithmContext*> {
  public:
    VALUE convert(MySqlParser::AlterBySetAlgorithmContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterBySetAlgorithmContext>(x, false, rb_cAlterBySetAlgorithmContext);
    }
  };

  template <>
  class To_Ruby<AlterBySetAlgorithmContextProxy*> {
  public:
    VALUE convert(AlterBySetAlgorithmContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterBySetAlgorithmContextProxy>(x, false, rb_cAlterBySetAlgorithmContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByChangeColumnContext*> {
  public:
    VALUE convert(MySqlParser::AlterByChangeColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByChangeColumnContext>(x, false, rb_cAlterByChangeColumnContext);
    }
  };

  template <>
  class To_Ruby<AlterByChangeColumnContextProxy*> {
  public:
    VALUE convert(AlterByChangeColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByChangeColumnContextProxy>(x, false, rb_cAlterByChangeColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddUniqueKeyContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddUniqueKeyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddUniqueKeyContext>(x, false, rb_cAlterByAddUniqueKeyContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddUniqueKeyContextProxy*> {
  public:
    VALUE convert(AlterByAddUniqueKeyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddUniqueKeyContextProxy>(x, false, rb_cAlterByAddUniqueKeyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropIndexContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropIndexContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropIndexContext>(x, false, rb_cAlterByDropIndexContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropIndexContextProxy*> {
  public:
    VALUE convert(AlterByDropIndexContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropIndexContextProxy>(x, false, rb_cAlterByDropIndexContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddColumnContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddColumnContext>(x, false, rb_cAlterByAddColumnContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddColumnContextProxy*> {
  public:
    VALUE convert(AlterByAddColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddColumnContextProxy>(x, false, rb_cAlterByAddColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByOrderContext*> {
  public:
    VALUE convert(MySqlParser::AlterByOrderContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByOrderContext>(x, false, rb_cAlterByOrderContext);
    }
  };

  template <>
  class To_Ruby<AlterByOrderContextProxy*> {
  public:
    VALUE convert(AlterByOrderContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByOrderContextProxy>(x, false, rb_cAlterByOrderContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByImportPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByImportPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByImportPartitionContext>(x, false, rb_cAlterByImportPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByImportPartitionContextProxy*> {
  public:
    VALUE convert(AlterByImportPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByImportPartitionContextProxy>(x, false, rb_cAlterByImportPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDropPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDropPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDropPartitionContext>(x, false, rb_cAlterByDropPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByDropPartitionContextProxy*> {
  public:
    VALUE convert(AlterByDropPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDropPartitionContextProxy>(x, false, rb_cAlterByDropPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByDiscardPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByDiscardPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByDiscardPartitionContext>(x, false, rb_cAlterByDiscardPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByDiscardPartitionContextProxy*> {
  public:
    VALUE convert(AlterByDiscardPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByDiscardPartitionContextProxy>(x, false, rb_cAlterByDiscardPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAddPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAddPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAddPartitionContext>(x, false, rb_cAlterByAddPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByAddPartitionContextProxy*> {
  public:
    VALUE convert(AlterByAddPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAddPartitionContextProxy>(x, false, rb_cAlterByAddPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRemovePartitioningContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRemovePartitioningContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRemovePartitioningContext>(x, false, rb_cAlterByRemovePartitioningContext);
    }
  };

  template <>
  class To_Ruby<AlterByRemovePartitioningContextProxy*> {
  public:
    VALUE convert(AlterByRemovePartitioningContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRemovePartitioningContextProxy>(x, false, rb_cAlterByRemovePartitioningContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByOptimizePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByOptimizePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByOptimizePartitionContext>(x, false, rb_cAlterByOptimizePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByOptimizePartitionContextProxy*> {
  public:
    VALUE convert(AlterByOptimizePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByOptimizePartitionContextProxy>(x, false, rb_cAlterByOptimizePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByCheckPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByCheckPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByCheckPartitionContext>(x, false, rb_cAlterByCheckPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByCheckPartitionContextProxy*> {
  public:
    VALUE convert(AlterByCheckPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByCheckPartitionContextProxy>(x, false, rb_cAlterByCheckPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByCoalescePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByCoalescePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByCoalescePartitionContext>(x, false, rb_cAlterByCoalescePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByCoalescePartitionContextProxy*> {
  public:
    VALUE convert(AlterByCoalescePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByCoalescePartitionContextProxy>(x, false, rb_cAlterByCoalescePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByReorganizePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByReorganizePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByReorganizePartitionContext>(x, false, rb_cAlterByReorganizePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByReorganizePartitionContextProxy*> {
  public:
    VALUE convert(AlterByReorganizePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByReorganizePartitionContextProxy>(x, false, rb_cAlterByReorganizePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByAnalyzePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByAnalyzePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByAnalyzePartitionContext>(x, false, rb_cAlterByAnalyzePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByAnalyzePartitionContextProxy*> {
  public:
    VALUE convert(AlterByAnalyzePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByAnalyzePartitionContextProxy>(x, false, rb_cAlterByAnalyzePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRebuildPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRebuildPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRebuildPartitionContext>(x, false, rb_cAlterByRebuildPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByRebuildPartitionContextProxy*> {
  public:
    VALUE convert(AlterByRebuildPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRebuildPartitionContextProxy>(x, false, rb_cAlterByRebuildPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByUpgradePartitioningContext*> {
  public:
    VALUE convert(MySqlParser::AlterByUpgradePartitioningContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByUpgradePartitioningContext>(x, false, rb_cAlterByUpgradePartitioningContext);
    }
  };

  template <>
  class To_Ruby<AlterByUpgradePartitioningContextProxy*> {
  public:
    VALUE convert(AlterByUpgradePartitioningContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByUpgradePartitioningContextProxy>(x, false, rb_cAlterByUpgradePartitioningContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByTruncatePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByTruncatePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByTruncatePartitionContext>(x, false, rb_cAlterByTruncatePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByTruncatePartitionContextProxy*> {
  public:
    VALUE convert(AlterByTruncatePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByTruncatePartitionContextProxy>(x, false, rb_cAlterByTruncatePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByRepairPartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByRepairPartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByRepairPartitionContext>(x, false, rb_cAlterByRepairPartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByRepairPartitionContextProxy*> {
  public:
    VALUE convert(AlterByRepairPartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByRepairPartitionContextProxy>(x, false, rb_cAlterByRepairPartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterByExchangePartitionContext*> {
  public:
    VALUE convert(MySqlParser::AlterByExchangePartitionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterByExchangePartitionContext>(x, false, rb_cAlterByExchangePartitionContext);
    }
  };

  template <>
  class To_Ruby<AlterByExchangePartitionContextProxy*> {
  public:
    VALUE convert(AlterByExchangePartitionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterByExchangePartitionContextProxy>(x, false, rb_cAlterByExchangePartitionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IfExistsContext*> {
  public:
    VALUE convert(MySqlParser::IfExistsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IfExistsContext>(x, false, rb_cIfExistsContext);
    }
  };

  template <>
  class To_Ruby<IfExistsContextProxy*> {
  public:
    VALUE convert(IfExistsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IfExistsContextProxy>(x, false, rb_cIfExistsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoleOptionContext*> {
  public:
    VALUE convert(MySqlParser::RoleOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoleOptionContext>(x, false, rb_cRoleOptionContext);
    }
  };

  template <>
  class To_Ruby<RoleOptionContextProxy*> {
  public:
    VALUE convert(RoleOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoleOptionContextProxy>(x, false, rb_cRoleOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RenameTableClauseContext*> {
  public:
    VALUE convert(MySqlParser::RenameTableClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RenameTableClauseContext>(x, false, rb_cRenameTableClauseContext);
    }
  };

  template <>
  class To_Ruby<RenameTableClauseContextProxy*> {
  public:
    VALUE convert(RenameTableClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RenameTableClauseContextProxy>(x, false, rb_cRenameTableClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConstantsContext*> {
  public:
    VALUE convert(MySqlParser::ConstantsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConstantsContext>(x, false, rb_cConstantsContext);
    }
  };

  template <>
  class To_Ruby<ConstantsContextProxy*> {
  public:
    VALUE convert(ConstantsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConstantsContextProxy>(x, false, rb_cConstantsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionsContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionsContext>(x, false, rb_cExpressionsContext);
    }
  };

  template <>
  class To_Ruby<ExpressionsContextProxy*> {
  public:
    VALUE convert(ExpressionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionsContextProxy>(x, false, rb_cExpressionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SingleDeleteStatementContext*> {
  public:
    VALUE convert(MySqlParser::SingleDeleteStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SingleDeleteStatementContext>(x, false, rb_cSingleDeleteStatementContext);
    }
  };

  template <>
  class To_Ruby<SingleDeleteStatementContextProxy*> {
  public:
    VALUE convert(SingleDeleteStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SingleDeleteStatementContextProxy>(x, false, rb_cSingleDeleteStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MultipleDeleteStatementContext*> {
  public:
    VALUE convert(MySqlParser::MultipleDeleteStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MultipleDeleteStatementContext>(x, false, rb_cMultipleDeleteStatementContext);
    }
  };

  template <>
  class To_Ruby<MultipleDeleteStatementContextProxy*> {
  public:
    VALUE convert(MultipleDeleteStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MultipleDeleteStatementContextProxy>(x, false, rb_cMultipleDeleteStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerOpenStatementContext*> {
  public:
    VALUE convert(MySqlParser::HandlerOpenStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerOpenStatementContext>(x, false, rb_cHandlerOpenStatementContext);
    }
  };

  template <>
  class To_Ruby<HandlerOpenStatementContextProxy*> {
  public:
    VALUE convert(HandlerOpenStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerOpenStatementContextProxy>(x, false, rb_cHandlerOpenStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerReadIndexStatementContext*> {
  public:
    VALUE convert(MySqlParser::HandlerReadIndexStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerReadIndexStatementContext>(x, false, rb_cHandlerReadIndexStatementContext);
    }
  };

  template <>
  class To_Ruby<HandlerReadIndexStatementContextProxy*> {
  public:
    VALUE convert(HandlerReadIndexStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerReadIndexStatementContextProxy>(x, false, rb_cHandlerReadIndexStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerReadStatementContext*> {
  public:
    VALUE convert(MySqlParser::HandlerReadStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerReadStatementContext>(x, false, rb_cHandlerReadStatementContext);
    }
  };

  template <>
  class To_Ruby<HandlerReadStatementContextProxy*> {
  public:
    VALUE convert(HandlerReadStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerReadStatementContextProxy>(x, false, rb_cHandlerReadStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerCloseStatementContext*> {
  public:
    VALUE convert(MySqlParser::HandlerCloseStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerCloseStatementContext>(x, false, rb_cHandlerCloseStatementContext);
    }
  };

  template <>
  class To_Ruby<HandlerCloseStatementContextProxy*> {
  public:
    VALUE convert(HandlerCloseStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerCloseStatementContextProxy>(x, false, rb_cHandlerCloseStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InsertStatementValueContext*> {
  public:
    VALUE convert(MySqlParser::InsertStatementValueContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InsertStatementValueContext>(x, false, rb_cInsertStatementValueContext);
    }
  };

  template <>
  class To_Ruby<InsertStatementValueContextProxy*> {
  public:
    VALUE convert(InsertStatementValueContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InsertStatementValueContextProxy>(x, false, rb_cInsertStatementValueContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UpdatedElementContext*> {
  public:
    VALUE convert(MySqlParser::UpdatedElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UpdatedElementContext>(x, false, rb_cUpdatedElementContext);
    }
  };

  template <>
  class To_Ruby<UpdatedElementContextProxy*> {
  public:
    VALUE convert(UpdatedElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UpdatedElementContextProxy>(x, false, rb_cUpdatedElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FullColumnNameListContext*> {
  public:
    VALUE convert(MySqlParser::FullColumnNameListContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FullColumnNameListContext>(x, false, rb_cFullColumnNameListContext);
    }
  };

  template <>
  class To_Ruby<FullColumnNameListContextProxy*> {
  public:
    VALUE convert(FullColumnNameListContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FullColumnNameListContextProxy>(x, false, rb_cFullColumnNameListContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AssignmentFieldContext*> {
  public:
    VALUE convert(MySqlParser::AssignmentFieldContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AssignmentFieldContext>(x, false, rb_cAssignmentFieldContext);
    }
  };

  template <>
  class To_Ruby<AssignmentFieldContextProxy*> {
  public:
    VALUE convert(AssignmentFieldContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AssignmentFieldContextProxy>(x, false, rb_cAssignmentFieldContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectFieldsIntoContext*> {
  public:
    VALUE convert(MySqlParser::SelectFieldsIntoContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectFieldsIntoContext>(x, false, rb_cSelectFieldsIntoContext);
    }
  };

  template <>
  class To_Ruby<SelectFieldsIntoContextProxy*> {
  public:
    VALUE convert(SelectFieldsIntoContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectFieldsIntoContextProxy>(x, false, rb_cSelectFieldsIntoContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectLinesIntoContext*> {
  public:
    VALUE convert(MySqlParser::SelectLinesIntoContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectLinesIntoContext>(x, false, rb_cSelectLinesIntoContext);
    }
  };

  template <>
  class To_Ruby<SelectLinesIntoContextProxy*> {
  public:
    VALUE convert(SelectLinesIntoContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectLinesIntoContextProxy>(x, false, rb_cSelectLinesIntoContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::QuerySpecificationNointoContext*> {
  public:
    VALUE convert(MySqlParser::QuerySpecificationNointoContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::QuerySpecificationNointoContext>(x, false, rb_cQuerySpecificationNointoContext);
    }
  };

  template <>
  class To_Ruby<QuerySpecificationNointoContextProxy*> {
  public:
    VALUE convert(QuerySpecificationNointoContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<QuerySpecificationNointoContextProxy>(x, false, rb_cQuerySpecificationNointoContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnionSelectContext*> {
  public:
    VALUE convert(MySqlParser::UnionSelectContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnionSelectContext>(x, false, rb_cUnionSelectContext);
    }
  };

  template <>
  class To_Ruby<UnionSelectContextProxy*> {
  public:
    VALUE convert(UnionSelectContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnionSelectContextProxy>(x, false, rb_cUnionSelectContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::QueryExpressionNointoContext*> {
  public:
    VALUE convert(MySqlParser::QueryExpressionNointoContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::QueryExpressionNointoContext>(x, false, rb_cQueryExpressionNointoContext);
    }
  };

  template <>
  class To_Ruby<QueryExpressionNointoContextProxy*> {
  public:
    VALUE convert(QueryExpressionNointoContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<QueryExpressionNointoContextProxy>(x, false, rb_cQueryExpressionNointoContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnionStatementContext*> {
  public:
    VALUE convert(MySqlParser::UnionStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnionStatementContext>(x, false, rb_cUnionStatementContext);
    }
  };

  template <>
  class To_Ruby<UnionStatementContextProxy*> {
  public:
    VALUE convert(UnionStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnionStatementContextProxy>(x, false, rb_cUnionStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OrderByClauseContext*> {
  public:
    VALUE convert(MySqlParser::OrderByClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OrderByClauseContext>(x, false, rb_cOrderByClauseContext);
    }
  };

  template <>
  class To_Ruby<OrderByClauseContextProxy*> {
  public:
    VALUE convert(OrderByClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OrderByClauseContextProxy>(x, false, rb_cOrderByClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LimitClauseContext*> {
  public:
    VALUE convert(MySqlParser::LimitClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LimitClauseContext>(x, false, rb_cLimitClauseContext);
    }
  };

  template <>
  class To_Ruby<LimitClauseContextProxy*> {
  public:
    VALUE convert(LimitClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LimitClauseContextProxy>(x, false, rb_cLimitClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LockClauseContext*> {
  public:
    VALUE convert(MySqlParser::LockClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LockClauseContext>(x, false, rb_cLockClauseContext);
    }
  };

  template <>
  class To_Ruby<LockClauseContextProxy*> {
  public:
    VALUE convert(LockClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LockClauseContextProxy>(x, false, rb_cLockClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::QuerySpecificationContext*> {
  public:
    VALUE convert(MySqlParser::QuerySpecificationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::QuerySpecificationContext>(x, false, rb_cQuerySpecificationContext);
    }
  };

  template <>
  class To_Ruby<QuerySpecificationContextProxy*> {
  public:
    VALUE convert(QuerySpecificationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<QuerySpecificationContextProxy>(x, false, rb_cQuerySpecificationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::QueryExpressionContext*> {
  public:
    VALUE convert(MySqlParser::QueryExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::QueryExpressionContext>(x, false, rb_cQueryExpressionContext);
    }
  };

  template <>
  class To_Ruby<QueryExpressionContextProxy*> {
  public:
    VALUE convert(QueryExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<QueryExpressionContextProxy>(x, false, rb_cQueryExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnionParenthesisSelectContext*> {
  public:
    VALUE convert(MySqlParser::UnionParenthesisSelectContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnionParenthesisSelectContext>(x, false, rb_cUnionParenthesisSelectContext);
    }
  };

  template <>
  class To_Ruby<UnionParenthesisSelectContextProxy*> {
  public:
    VALUE convert(UnionParenthesisSelectContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnionParenthesisSelectContextProxy>(x, false, rb_cUnionParenthesisSelectContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnionParenthesisContext*> {
  public:
    VALUE convert(MySqlParser::UnionParenthesisContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnionParenthesisContext>(x, false, rb_cUnionParenthesisContext);
    }
  };

  template <>
  class To_Ruby<UnionParenthesisContextProxy*> {
  public:
    VALUE convert(UnionParenthesisContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnionParenthesisContextProxy>(x, false, rb_cUnionParenthesisContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleSelectContext*> {
  public:
    VALUE convert(MySqlParser::SimpleSelectContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleSelectContext>(x, false, rb_cSimpleSelectContext);
    }
  };

  template <>
  class To_Ruby<SimpleSelectContextProxy*> {
  public:
    VALUE convert(SimpleSelectContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleSelectContextProxy>(x, false, rb_cSimpleSelectContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ParenthesisSelectContext*> {
  public:
    VALUE convert(MySqlParser::ParenthesisSelectContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ParenthesisSelectContext>(x, false, rb_cParenthesisSelectContext);
    }
  };

  template <>
  class To_Ruby<ParenthesisSelectContextProxy*> {
  public:
    VALUE convert(ParenthesisSelectContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ParenthesisSelectContextProxy>(x, false, rb_cParenthesisSelectContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WithLateralStatementContext*> {
  public:
    VALUE convert(MySqlParser::WithLateralStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WithLateralStatementContext>(x, false, rb_cWithLateralStatementContext);
    }
  };

  template <>
  class To_Ruby<WithLateralStatementContextProxy*> {
  public:
    VALUE convert(WithLateralStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WithLateralStatementContextProxy>(x, false, rb_cWithLateralStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LateralStatementContext*> {
  public:
    VALUE convert(MySqlParser::LateralStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LateralStatementContext>(x, false, rb_cLateralStatementContext);
    }
  };

  template <>
  class To_Ruby<LateralStatementContextProxy*> {
  public:
    VALUE convert(LateralStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LateralStatementContextProxy>(x, false, rb_cLateralStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SingleUpdateStatementContext*> {
  public:
    VALUE convert(MySqlParser::SingleUpdateStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SingleUpdateStatementContext>(x, false, rb_cSingleUpdateStatementContext);
    }
  };

  template <>
  class To_Ruby<SingleUpdateStatementContextProxy*> {
  public:
    VALUE convert(SingleUpdateStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SingleUpdateStatementContextProxy>(x, false, rb_cSingleUpdateStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MultipleUpdateStatementContext*> {
  public:
    VALUE convert(MySqlParser::MultipleUpdateStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MultipleUpdateStatementContext>(x, false, rb_cMultipleUpdateStatementContext);
    }
  };

  template <>
  class To_Ruby<MultipleUpdateStatementContextProxy*> {
  public:
    VALUE convert(MultipleUpdateStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MultipleUpdateStatementContextProxy>(x, false, rb_cMultipleUpdateStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionsWithDefaultsContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionsWithDefaultsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionsWithDefaultsContext>(x, false, rb_cExpressionsWithDefaultsContext);
    }
  };

  template <>
  class To_Ruby<ExpressionsWithDefaultsContextProxy*> {
  public:
    VALUE convert(ExpressionsWithDefaultsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionsWithDefaultsContextProxy>(x, false, rb_cExpressionsWithDefaultsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LimitClauseAtomContext*> {
  public:
    VALUE convert(MySqlParser::LimitClauseAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LimitClauseAtomContext>(x, false, rb_cLimitClauseAtomContext);
    }
  };

  template <>
  class To_Ruby<LimitClauseAtomContextProxy*> {
  public:
    VALUE convert(LimitClauseAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LimitClauseAtomContextProxy>(x, false, rb_cLimitClauseAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourcesContext*> {
  public:
    VALUE convert(MySqlParser::TableSourcesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourcesContext>(x, false, rb_cTableSourcesContext);
    }
  };

  template <>
  class To_Ruby<TableSourcesContextProxy*> {
  public:
    VALUE convert(TableSourcesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourcesContextProxy>(x, false, rb_cTableSourcesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ComparisonOperatorContext*> {
  public:
    VALUE convert(MySqlParser::ComparisonOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ComparisonOperatorContext>(x, false, rb_cComparisonOperatorContext);
    }
  };

  template <>
  class To_Ruby<ComparisonOperatorContextProxy*> {
  public:
    VALUE convert(ComparisonOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ComparisonOperatorContextProxy>(x, false, rb_cComparisonOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OrderByExpressionContext*> {
  public:
    VALUE convert(MySqlParser::OrderByExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OrderByExpressionContext>(x, false, rb_cOrderByExpressionContext);
    }
  };

  template <>
  class To_Ruby<OrderByExpressionContextProxy*> {
  public:
    VALUE convert(OrderByExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OrderByExpressionContextProxy>(x, false, rb_cOrderByExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourceContext*> {
  public:
    VALUE convert(MySqlParser::TableSourceContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourceContext>(x, false, rb_cTableSourceContext);
    }
  };

  template <>
  class To_Ruby<TableSourceContextProxy*> {
  public:
    VALUE convert(TableSourceContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourceContextProxy>(x, false, rb_cTableSourceContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonTableContext*> {
  public:
    VALUE convert(MySqlParser::JsonTableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonTableContext>(x, false, rb_cJsonTableContext);
    }
  };

  template <>
  class To_Ruby<JsonTableContextProxy*> {
  public:
    VALUE convert(JsonTableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonTableContextProxy>(x, false, rb_cJsonTableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableJsonContext*> {
  public:
    VALUE convert(MySqlParser::TableJsonContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableJsonContext>(x, false, rb_cTableJsonContext);
    }
  };

  template <>
  class To_Ruby<TableJsonContextProxy*> {
  public:
    VALUE convert(TableJsonContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableJsonContextProxy>(x, false, rb_cTableJsonContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourceNestedContext*> {
  public:
    VALUE convert(MySqlParser::TableSourceNestedContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourceNestedContext>(x, false, rb_cTableSourceNestedContext);
    }
  };

  template <>
  class To_Ruby<TableSourceNestedContextProxy*> {
  public:
    VALUE convert(TableSourceNestedContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourceNestedContextProxy>(x, false, rb_cTableSourceNestedContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourceItemContext*> {
  public:
    VALUE convert(MySqlParser::TableSourceItemContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourceItemContext>(x, false, rb_cTableSourceItemContext);
    }
  };

  template <>
  class To_Ruby<TableSourceItemContextProxy*> {
  public:
    VALUE convert(TableSourceItemContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourceItemContextProxy>(x, false, rb_cTableSourceItemContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JoinPartContext*> {
  public:
    VALUE convert(MySqlParser::JoinPartContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JoinPartContext>(x, false, rb_cJoinPartContext);
    }
  };

  template <>
  class To_Ruby<JoinPartContextProxy*> {
  public:
    VALUE convert(JoinPartContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JoinPartContextProxy>(x, false, rb_cJoinPartContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourceBaseContext*> {
  public:
    VALUE convert(MySqlParser::TableSourceBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourceBaseContext>(x, false, rb_cTableSourceBaseContext);
    }
  };

  template <>
  class To_Ruby<TableSourceBaseContextProxy*> {
  public:
    VALUE convert(TableSourceBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourceBaseContextProxy>(x, false, rb_cTableSourceBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubqueryTableItemContext*> {
  public:
    VALUE convert(MySqlParser::SubqueryTableItemContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubqueryTableItemContext>(x, false, rb_cSubqueryTableItemContext);
    }
  };

  template <>
  class To_Ruby<SubqueryTableItemContextProxy*> {
  public:
    VALUE convert(SubqueryTableItemContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubqueryTableItemContextProxy>(x, false, rb_cSubqueryTableItemContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AtomTableItemContext*> {
  public:
    VALUE convert(MySqlParser::AtomTableItemContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AtomTableItemContext>(x, false, rb_cAtomTableItemContext);
    }
  };

  template <>
  class To_Ruby<AtomTableItemContextProxy*> {
  public:
    VALUE convert(AtomTableItemContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AtomTableItemContextProxy>(x, false, rb_cAtomTableItemContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexHintContext*> {
  public:
    VALUE convert(MySqlParser::IndexHintContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexHintContext>(x, false, rb_cIndexHintContext);
    }
  };

  template <>
  class To_Ruby<IndexHintContextProxy*> {
  public:
    VALUE convert(IndexHintContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexHintContextProxy>(x, false, rb_cIndexHintContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableSourcesItemContext*> {
  public:
    VALUE convert(MySqlParser::TableSourcesItemContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableSourcesItemContext>(x, false, rb_cTableSourcesItemContext);
    }
  };

  template <>
  class To_Ruby<TableSourcesItemContextProxy*> {
  public:
    VALUE convert(TableSourcesItemContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableSourcesItemContextProxy>(x, false, rb_cTableSourcesItemContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexHintTypeContext*> {
  public:
    VALUE convert(MySqlParser::IndexHintTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexHintTypeContext>(x, false, rb_cIndexHintTypeContext);
    }
  };

  template <>
  class To_Ruby<IndexHintTypeContextProxy*> {
  public:
    VALUE convert(IndexHintTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexHintTypeContextProxy>(x, false, rb_cIndexHintTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InnerJoinContext*> {
  public:
    VALUE convert(MySqlParser::InnerJoinContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InnerJoinContext>(x, false, rb_cInnerJoinContext);
    }
  };

  template <>
  class To_Ruby<InnerJoinContextProxy*> {
  public:
    VALUE convert(InnerJoinContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InnerJoinContextProxy>(x, false, rb_cInnerJoinContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JoinSpecContext*> {
  public:
    VALUE convert(MySqlParser::JoinSpecContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JoinSpecContext>(x, false, rb_cJoinSpecContext);
    }
  };

  template <>
  class To_Ruby<JoinSpecContextProxy*> {
  public:
    VALUE convert(JoinSpecContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JoinSpecContextProxy>(x, false, rb_cJoinSpecContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NaturalJoinContext*> {
  public:
    VALUE convert(MySqlParser::NaturalJoinContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NaturalJoinContext>(x, false, rb_cNaturalJoinContext);
    }
  };

  template <>
  class To_Ruby<NaturalJoinContextProxy*> {
  public:
    VALUE convert(NaturalJoinContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NaturalJoinContextProxy>(x, false, rb_cNaturalJoinContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OuterJoinContext*> {
  public:
    VALUE convert(MySqlParser::OuterJoinContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OuterJoinContext>(x, false, rb_cOuterJoinContext);
    }
  };

  template <>
  class To_Ruby<OuterJoinContextProxy*> {
  public:
    VALUE convert(OuterJoinContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OuterJoinContextProxy>(x, false, rb_cOuterJoinContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StraightJoinContext*> {
  public:
    VALUE convert(MySqlParser::StraightJoinContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StraightJoinContext>(x, false, rb_cStraightJoinContext);
    }
  };

  template <>
  class To_Ruby<StraightJoinContextProxy*> {
  public:
    VALUE convert(StraightJoinContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StraightJoinContextProxy>(x, false, rb_cStraightJoinContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectElementsContext*> {
  public:
    VALUE convert(MySqlParser::SelectElementsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectElementsContext>(x, false, rb_cSelectElementsContext);
    }
  };

  template <>
  class To_Ruby<SelectElementsContextProxy*> {
  public:
    VALUE convert(SelectElementsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectElementsContextProxy>(x, false, rb_cSelectElementsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FromClauseContext*> {
  public:
    VALUE convert(MySqlParser::FromClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FromClauseContext>(x, false, rb_cFromClauseContext);
    }
  };

  template <>
  class To_Ruby<FromClauseContextProxy*> {
  public:
    VALUE convert(FromClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FromClauseContextProxy>(x, false, rb_cFromClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectSpecContext*> {
  public:
    VALUE convert(MySqlParser::SelectSpecContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectSpecContext>(x, false, rb_cSelectSpecContext);
    }
  };

  template <>
  class To_Ruby<SelectSpecContextProxy*> {
  public:
    VALUE convert(SelectSpecContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectSpecContextProxy>(x, false, rb_cSelectSpecContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectIntoExpressionContext*> {
  public:
    VALUE convert(MySqlParser::SelectIntoExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectIntoExpressionContext>(x, false, rb_cSelectIntoExpressionContext);
    }
  };

  template <>
  class To_Ruby<SelectIntoExpressionContextProxy*> {
  public:
    VALUE convert(SelectIntoExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectIntoExpressionContextProxy>(x, false, rb_cSelectIntoExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GroupByClauseContext*> {
  public:
    VALUE convert(MySqlParser::GroupByClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GroupByClauseContext>(x, false, rb_cGroupByClauseContext);
    }
  };

  template <>
  class To_Ruby<GroupByClauseContextProxy*> {
  public:
    VALUE convert(GroupByClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GroupByClauseContextProxy>(x, false, rb_cGroupByClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HavingClauseContext*> {
  public:
    VALUE convert(MySqlParser::HavingClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HavingClauseContext>(x, false, rb_cHavingClauseContext);
    }
  };

  template <>
  class To_Ruby<HavingClauseContextProxy*> {
  public:
    VALUE convert(HavingClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HavingClauseContextProxy>(x, false, rb_cHavingClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WindowClauseContext*> {
  public:
    VALUE convert(MySqlParser::WindowClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WindowClauseContext>(x, false, rb_cWindowClauseContext);
    }
  };

  template <>
  class To_Ruby<WindowClauseContextProxy*> {
  public:
    VALUE convert(WindowClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WindowClauseContextProxy>(x, false, rb_cWindowClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonColumnListContext*> {
  public:
    VALUE convert(MySqlParser::JsonColumnListContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonColumnListContext>(x, false, rb_cJsonColumnListContext);
    }
  };

  template <>
  class To_Ruby<JsonColumnListContextProxy*> {
  public:
    VALUE convert(JsonColumnListContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonColumnListContextProxy>(x, false, rb_cJsonColumnListContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonColumnContext*> {
  public:
    VALUE convert(MySqlParser::JsonColumnContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonColumnContext>(x, false, rb_cJsonColumnContext);
    }
  };

  template <>
  class To_Ruby<JsonColumnContextProxy*> {
  public:
    VALUE convert(JsonColumnContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonColumnContextProxy>(x, false, rb_cJsonColumnContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonOnEmptyContext*> {
  public:
    VALUE convert(MySqlParser::JsonOnEmptyContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonOnEmptyContext>(x, false, rb_cJsonOnEmptyContext);
    }
  };

  template <>
  class To_Ruby<JsonOnEmptyContextProxy*> {
  public:
    VALUE convert(JsonOnEmptyContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonOnEmptyContextProxy>(x, false, rb_cJsonOnEmptyContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonOnErrorContext*> {
  public:
    VALUE convert(MySqlParser::JsonOnErrorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonOnErrorContext>(x, false, rb_cJsonOnErrorContext);
    }
  };

  template <>
  class To_Ruby<JsonOnErrorContextProxy*> {
  public:
    VALUE convert(JsonOnErrorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonOnErrorContextProxy>(x, false, rb_cJsonOnErrorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectElementContext*> {
  public:
    VALUE convert(MySqlParser::SelectElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectElementContext>(x, false, rb_cSelectElementContext);
    }
  };

  template <>
  class To_Ruby<SelectElementContextProxy*> {
  public:
    VALUE convert(SelectElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectElementContextProxy>(x, false, rb_cSelectElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectExpressionElementContext*> {
  public:
    VALUE convert(MySqlParser::SelectExpressionElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectExpressionElementContext>(x, false, rb_cSelectExpressionElementContext);
    }
  };

  template <>
  class To_Ruby<SelectExpressionElementContextProxy*> {
  public:
    VALUE convert(SelectExpressionElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectExpressionElementContextProxy>(x, false, rb_cSelectExpressionElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::FunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionCallContext>(x, false, rb_cFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<FunctionCallContextProxy*> {
  public:
    VALUE convert(FunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionCallContextProxy>(x, false, rb_cFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectFunctionElementContext*> {
  public:
    VALUE convert(MySqlParser::SelectFunctionElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectFunctionElementContext>(x, false, rb_cSelectFunctionElementContext);
    }
  };

  template <>
  class To_Ruby<SelectFunctionElementContextProxy*> {
  public:
    VALUE convert(SelectFunctionElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectFunctionElementContextProxy>(x, false, rb_cSelectFunctionElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectStarElementContext*> {
  public:
    VALUE convert(MySqlParser::SelectStarElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectStarElementContext>(x, false, rb_cSelectStarElementContext);
    }
  };

  template <>
  class To_Ruby<SelectStarElementContextProxy*> {
  public:
    VALUE convert(SelectStarElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectStarElementContextProxy>(x, false, rb_cSelectStarElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectColumnElementContext*> {
  public:
    VALUE convert(MySqlParser::SelectColumnElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectColumnElementContext>(x, false, rb_cSelectColumnElementContext);
    }
  };

  template <>
  class To_Ruby<SelectColumnElementContextProxy*> {
  public:
    VALUE convert(SelectColumnElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectColumnElementContextProxy>(x, false, rb_cSelectColumnElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectIntoVariablesContext*> {
  public:
    VALUE convert(MySqlParser::SelectIntoVariablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectIntoVariablesContext>(x, false, rb_cSelectIntoVariablesContext);
    }
  };

  template <>
  class To_Ruby<SelectIntoVariablesContextProxy*> {
  public:
    VALUE convert(SelectIntoVariablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectIntoVariablesContextProxy>(x, false, rb_cSelectIntoVariablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectIntoTextFileContext*> {
  public:
    VALUE convert(MySqlParser::SelectIntoTextFileContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectIntoTextFileContext>(x, false, rb_cSelectIntoTextFileContext);
    }
  };

  template <>
  class To_Ruby<SelectIntoTextFileContextProxy*> {
  public:
    VALUE convert(SelectIntoTextFileContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectIntoTextFileContextProxy>(x, false, rb_cSelectIntoTextFileContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SelectIntoDumpFileContext*> {
  public:
    VALUE convert(MySqlParser::SelectIntoDumpFileContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SelectIntoDumpFileContext>(x, false, rb_cSelectIntoDumpFileContext);
    }
  };

  template <>
  class To_Ruby<SelectIntoDumpFileContextProxy*> {
  public:
    VALUE convert(SelectIntoDumpFileContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SelectIntoDumpFileContextProxy>(x, false, rb_cSelectIntoDumpFileContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GroupByItemContext*> {
  public:
    VALUE convert(MySqlParser::GroupByItemContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GroupByItemContext>(x, false, rb_cGroupByItemContext);
    }
  };

  template <>
  class To_Ruby<GroupByItemContextProxy*> {
  public:
    VALUE convert(GroupByItemContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GroupByItemContextProxy>(x, false, rb_cGroupByItemContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WindowNameContext*> {
  public:
    VALUE convert(MySqlParser::WindowNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WindowNameContext>(x, false, rb_cWindowNameContext);
    }
  };

  template <>
  class To_Ruby<WindowNameContextProxy*> {
  public:
    VALUE convert(WindowNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WindowNameContextProxy>(x, false, rb_cWindowNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WindowSpecContext*> {
  public:
    VALUE convert(MySqlParser::WindowSpecContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WindowSpecContext>(x, false, rb_cWindowSpecContext);
    }
  };

  template <>
  class To_Ruby<WindowSpecContextProxy*> {
  public:
    VALUE convert(WindowSpecContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WindowSpecContextProxy>(x, false, rb_cWindowSpecContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MysqlVariableContext*> {
  public:
    VALUE convert(MySqlParser::MysqlVariableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MysqlVariableContext>(x, false, rb_cMysqlVariableContext);
    }
  };

  template <>
  class To_Ruby<MysqlVariableContextProxy*> {
  public:
    VALUE convert(MysqlVariableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MysqlVariableContextProxy>(x, false, rb_cMysqlVariableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleIdContext*> {
  public:
    VALUE convert(MySqlParser::SimpleIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleIdContext>(x, false, rb_cSimpleIdContext);
    }
  };

  template <>
  class To_Ruby<SimpleIdContextProxy*> {
  public:
    VALUE convert(SimpleIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleIdContextProxy>(x, false, rb_cSimpleIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TransactionModeContext*> {
  public:
    VALUE convert(MySqlParser::TransactionModeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TransactionModeContext>(x, false, rb_cTransactionModeContext);
    }
  };

  template <>
  class To_Ruby<TransactionModeContextProxy*> {
  public:
    VALUE convert(TransactionModeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TransactionModeContextProxy>(x, false, rb_cTransactionModeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LockTableElementContext*> {
  public:
    VALUE convert(MySqlParser::LockTableElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LockTableElementContext>(x, false, rb_cLockTableElementContext);
    }
  };

  template <>
  class To_Ruby<LockTableElementContextProxy*> {
  public:
    VALUE convert(LockTableElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LockTableElementContextProxy>(x, false, rb_cLockTableElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetAutocommitStatementContext*> {
  public:
    VALUE convert(MySqlParser::SetAutocommitStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetAutocommitStatementContext>(x, false, rb_cSetAutocommitStatementContext);
    }
  };

  template <>
  class To_Ruby<SetAutocommitStatementContextProxy*> {
  public:
    VALUE convert(SetAutocommitStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetAutocommitStatementContextProxy>(x, false, rb_cSetAutocommitStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetTransactionStatementContext*> {
  public:
    VALUE convert(MySqlParser::SetTransactionStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetTransactionStatementContext>(x, false, rb_cSetTransactionStatementContext);
    }
  };

  template <>
  class To_Ruby<SetTransactionStatementContextProxy*> {
  public:
    VALUE convert(SetTransactionStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetTransactionStatementContextProxy>(x, false, rb_cSetTransactionStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TransactionOptionContext*> {
  public:
    VALUE convert(MySqlParser::TransactionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TransactionOptionContext>(x, false, rb_cTransactionOptionContext);
    }
  };

  template <>
  class To_Ruby<TransactionOptionContextProxy*> {
  public:
    VALUE convert(TransactionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TransactionOptionContextProxy>(x, false, rb_cTransactionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LockActionContext*> {
  public:
    VALUE convert(MySqlParser::LockActionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LockActionContext>(x, false, rb_cLockActionContext);
    }
  };

  template <>
  class To_Ruby<LockActionContextProxy*> {
  public:
    VALUE convert(LockActionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LockActionContextProxy>(x, false, rb_cLockActionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TransactionLevelContext*> {
  public:
    VALUE convert(MySqlParser::TransactionLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TransactionLevelContext>(x, false, rb_cTransactionLevelContext);
    }
  };

  template <>
  class To_Ruby<TransactionLevelContextProxy*> {
  public:
    VALUE convert(TransactionLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TransactionLevelContextProxy>(x, false, rb_cTransactionLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterOptionContext>(x, false, rb_cMasterOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterOptionContextProxy*> {
  public:
    VALUE convert(MasterOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterOptionContextProxy>(x, false, rb_cMasterOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ChannelOptionContext*> {
  public:
    VALUE convert(MySqlParser::ChannelOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ChannelOptionContext>(x, false, rb_cChannelOptionContext);
    }
  };

  template <>
  class To_Ruby<ChannelOptionContextProxy*> {
  public:
    VALUE convert(ChannelOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ChannelOptionContextProxy>(x, false, rb_cChannelOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ReplicationFilterContext*> {
  public:
    VALUE convert(MySqlParser::ReplicationFilterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ReplicationFilterContext>(x, false, rb_cReplicationFilterContext);
    }
  };

  template <>
  class To_Ruby<ReplicationFilterContextProxy*> {
  public:
    VALUE convert(ReplicationFilterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ReplicationFilterContextProxy>(x, false, rb_cReplicationFilterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ThreadTypeContext*> {
  public:
    VALUE convert(MySqlParser::ThreadTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ThreadTypeContext>(x, false, rb_cThreadTypeContext);
    }
  };

  template <>
  class To_Ruby<ThreadTypeContextProxy*> {
  public:
    VALUE convert(ThreadTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ThreadTypeContextProxy>(x, false, rb_cThreadTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UntilOptionContext*> {
  public:
    VALUE convert(MySqlParser::UntilOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UntilOptionContext>(x, false, rb_cUntilOptionContext);
    }
  };

  template <>
  class To_Ruby<UntilOptionContextProxy*> {
  public:
    VALUE convert(UntilOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UntilOptionContextProxy>(x, false, rb_cUntilOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConnectionOptionContext*> {
  public:
    VALUE convert(MySqlParser::ConnectionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConnectionOptionContext>(x, false, rb_cConnectionOptionContext);
    }
  };

  template <>
  class To_Ruby<ConnectionOptionContextProxy*> {
  public:
    VALUE convert(ConnectionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConnectionOptionContextProxy>(x, false, rb_cConnectionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StringMasterOptionContext*> {
  public:
    VALUE convert(MySqlParser::StringMasterOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StringMasterOptionContext>(x, false, rb_cStringMasterOptionContext);
    }
  };

  template <>
  class To_Ruby<StringMasterOptionContextProxy*> {
  public:
    VALUE convert(StringMasterOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StringMasterOptionContextProxy>(x, false, rb_cStringMasterOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterStringOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterStringOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterStringOptionContext>(x, false, rb_cMasterStringOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterStringOptionContextProxy*> {
  public:
    VALUE convert(MasterStringOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterStringOptionContextProxy>(x, false, rb_cMasterStringOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterRealOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterRealOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterRealOptionContext>(x, false, rb_cMasterRealOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterRealOptionContextProxy*> {
  public:
    VALUE convert(MasterRealOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterRealOptionContextProxy>(x, false, rb_cMasterRealOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BoolMasterOptionContext*> {
  public:
    VALUE convert(MySqlParser::BoolMasterOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BoolMasterOptionContext>(x, false, rb_cBoolMasterOptionContext);
    }
  };

  template <>
  class To_Ruby<BoolMasterOptionContextProxy*> {
  public:
    VALUE convert(BoolMasterOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BoolMasterOptionContextProxy>(x, false, rb_cBoolMasterOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterBoolOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterBoolOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterBoolOptionContext>(x, false, rb_cMasterBoolOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterBoolOptionContextProxy*> {
  public:
    VALUE convert(MasterBoolOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterBoolOptionContextProxy>(x, false, rb_cMasterBoolOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterUidListOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterUidListOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterUidListOptionContext>(x, false, rb_cMasterUidListOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterUidListOptionContextProxy*> {
  public:
    VALUE convert(MasterUidListOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterUidListOptionContextProxy>(x, false, rb_cMasterUidListOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DecimalMasterOptionContext*> {
  public:
    VALUE convert(MySqlParser::DecimalMasterOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DecimalMasterOptionContext>(x, false, rb_cDecimalMasterOptionContext);
    }
  };

  template <>
  class To_Ruby<DecimalMasterOptionContextProxy*> {
  public:
    VALUE convert(DecimalMasterOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DecimalMasterOptionContextProxy>(x, false, rb_cDecimalMasterOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterDecimalOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterDecimalOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterDecimalOptionContext>(x, false, rb_cMasterDecimalOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterDecimalOptionContextProxy*> {
  public:
    VALUE convert(MasterDecimalOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterDecimalOptionContextProxy>(x, false, rb_cMasterDecimalOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WildIgnoreTableReplicationContext*> {
  public:
    VALUE convert(MySqlParser::WildIgnoreTableReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WildIgnoreTableReplicationContext>(x, false, rb_cWildIgnoreTableReplicationContext);
    }
  };

  template <>
  class To_Ruby<WildIgnoreTableReplicationContextProxy*> {
  public:
    VALUE convert(WildIgnoreTableReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WildIgnoreTableReplicationContextProxy>(x, false, rb_cWildIgnoreTableReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleStringsContext*> {
  public:
    VALUE convert(MySqlParser::SimpleStringsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleStringsContext>(x, false, rb_cSimpleStringsContext);
    }
  };

  template <>
  class To_Ruby<SimpleStringsContextProxy*> {
  public:
    VALUE convert(SimpleStringsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleStringsContextProxy>(x, false, rb_cSimpleStringsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DoTableReplicationContext*> {
  public:
    VALUE convert(MySqlParser::DoTableReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DoTableReplicationContext>(x, false, rb_cDoTableReplicationContext);
    }
  };

  template <>
  class To_Ruby<DoTableReplicationContextProxy*> {
  public:
    VALUE convert(DoTableReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DoTableReplicationContextProxy>(x, false, rb_cDoTableReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IgnoreTableReplicationContext*> {
  public:
    VALUE convert(MySqlParser::IgnoreTableReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IgnoreTableReplicationContext>(x, false, rb_cIgnoreTableReplicationContext);
    }
  };

  template <>
  class To_Ruby<IgnoreTableReplicationContextProxy*> {
  public:
    VALUE convert(IgnoreTableReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IgnoreTableReplicationContextProxy>(x, false, rb_cIgnoreTableReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RewriteDbReplicationContext*> {
  public:
    VALUE convert(MySqlParser::RewriteDbReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RewriteDbReplicationContext>(x, false, rb_cRewriteDbReplicationContext);
    }
  };

  template <>
  class To_Ruby<RewriteDbReplicationContextProxy*> {
  public:
    VALUE convert(RewriteDbReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RewriteDbReplicationContextProxy>(x, false, rb_cRewriteDbReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TablePairContext*> {
  public:
    VALUE convert(MySqlParser::TablePairContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TablePairContext>(x, false, rb_cTablePairContext);
    }
  };

  template <>
  class To_Ruby<TablePairContextProxy*> {
  public:
    VALUE convert(TablePairContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TablePairContextProxy>(x, false, rb_cTablePairContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DoDbReplicationContext*> {
  public:
    VALUE convert(MySqlParser::DoDbReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DoDbReplicationContext>(x, false, rb_cDoDbReplicationContext);
    }
  };

  template <>
  class To_Ruby<DoDbReplicationContextProxy*> {
  public:
    VALUE convert(DoDbReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DoDbReplicationContextProxy>(x, false, rb_cDoDbReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IgnoreDbReplicationContext*> {
  public:
    VALUE convert(MySqlParser::IgnoreDbReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IgnoreDbReplicationContext>(x, false, rb_cIgnoreDbReplicationContext);
    }
  };

  template <>
  class To_Ruby<IgnoreDbReplicationContextProxy*> {
  public:
    VALUE convert(IgnoreDbReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IgnoreDbReplicationContextProxy>(x, false, rb_cIgnoreDbReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WildDoTableReplicationContext*> {
  public:
    VALUE convert(MySqlParser::WildDoTableReplicationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WildDoTableReplicationContext>(x, false, rb_cWildDoTableReplicationContext);
    }
  };

  template <>
  class To_Ruby<WildDoTableReplicationContextProxy*> {
  public:
    VALUE convert(WildDoTableReplicationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WildDoTableReplicationContextProxy>(x, false, rb_cWildDoTableReplicationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GtidsUntilOptionContext*> {
  public:
    VALUE convert(MySqlParser::GtidsUntilOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GtidsUntilOptionContext>(x, false, rb_cGtidsUntilOptionContext);
    }
  };

  template <>
  class To_Ruby<GtidsUntilOptionContextProxy*> {
  public:
    VALUE convert(GtidsUntilOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GtidsUntilOptionContextProxy>(x, false, rb_cGtidsUntilOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GtuidSetContext*> {
  public:
    VALUE convert(MySqlParser::GtuidSetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GtuidSetContext>(x, false, rb_cGtuidSetContext);
    }
  };

  template <>
  class To_Ruby<GtuidSetContextProxy*> {
  public:
    VALUE convert(GtuidSetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GtuidSetContextProxy>(x, false, rb_cGtuidSetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SqlGapsUntilOptionContext*> {
  public:
    VALUE convert(MySqlParser::SqlGapsUntilOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SqlGapsUntilOptionContext>(x, false, rb_cSqlGapsUntilOptionContext);
    }
  };

  template <>
  class To_Ruby<SqlGapsUntilOptionContextProxy*> {
  public:
    VALUE convert(SqlGapsUntilOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SqlGapsUntilOptionContextProxy>(x, false, rb_cSqlGapsUntilOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MasterLogUntilOptionContext*> {
  public:
    VALUE convert(MySqlParser::MasterLogUntilOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MasterLogUntilOptionContext>(x, false, rb_cMasterLogUntilOptionContext);
    }
  };

  template <>
  class To_Ruby<MasterLogUntilOptionContextProxy*> {
  public:
    VALUE convert(MasterLogUntilOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MasterLogUntilOptionContextProxy>(x, false, rb_cMasterLogUntilOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RelayLogUntilOptionContext*> {
  public:
    VALUE convert(MySqlParser::RelayLogUntilOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RelayLogUntilOptionContext>(x, false, rb_cRelayLogUntilOptionContext);
    }
  };

  template <>
  class To_Ruby<RelayLogUntilOptionContextProxy*> {
  public:
    VALUE convert(RelayLogUntilOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RelayLogUntilOptionContextProxy>(x, false, rb_cRelayLogUntilOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PluginDirConnectionOptionContext*> {
  public:
    VALUE convert(MySqlParser::PluginDirConnectionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PluginDirConnectionOptionContext>(x, false, rb_cPluginDirConnectionOptionContext);
    }
  };

  template <>
  class To_Ruby<PluginDirConnectionOptionContextProxy*> {
  public:
    VALUE convert(PluginDirConnectionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PluginDirConnectionOptionContextProxy>(x, false, rb_cPluginDirConnectionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserConnectionOptionContext*> {
  public:
    VALUE convert(MySqlParser::UserConnectionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserConnectionOptionContext>(x, false, rb_cUserConnectionOptionContext);
    }
  };

  template <>
  class To_Ruby<UserConnectionOptionContextProxy*> {
  public:
    VALUE convert(UserConnectionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserConnectionOptionContextProxy>(x, false, rb_cUserConnectionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefaultAuthConnectionOptionContext*> {
  public:
    VALUE convert(MySqlParser::DefaultAuthConnectionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefaultAuthConnectionOptionContext>(x, false, rb_cDefaultAuthConnectionOptionContext);
    }
  };

  template <>
  class To_Ruby<DefaultAuthConnectionOptionContextProxy*> {
  public:
    VALUE convert(DefaultAuthConnectionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefaultAuthConnectionOptionContextProxy>(x, false, rb_cDefaultAuthConnectionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PasswordConnectionOptionContext*> {
  public:
    VALUE convert(MySqlParser::PasswordConnectionOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PasswordConnectionOptionContext>(x, false, rb_cPasswordConnectionOptionContext);
    }
  };

  template <>
  class To_Ruby<PasswordConnectionOptionContextProxy*> {
  public:
    VALUE convert(PasswordConnectionOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PasswordConnectionOptionContextProxy>(x, false, rb_cPasswordConnectionOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UuidSetContext*> {
  public:
    VALUE convert(MySqlParser::UuidSetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UuidSetContext>(x, false, rb_cUuidSetContext);
    }
  };

  template <>
  class To_Ruby<UuidSetContextProxy*> {
  public:
    VALUE convert(UuidSetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UuidSetContextProxy>(x, false, rb_cUuidSetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XidContext*> {
  public:
    VALUE convert(MySqlParser::XidContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XidContext>(x, false, rb_cXidContext);
    }
  };

  template <>
  class To_Ruby<XidContextProxy*> {
  public:
    VALUE convert(XidContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XidContextProxy>(x, false, rb_cXidContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserVariablesContext*> {
  public:
    VALUE convert(MySqlParser::UserVariablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserVariablesContext>(x, false, rb_cUserVariablesContext);
    }
  };

  template <>
  class To_Ruby<UserVariablesContextProxy*> {
  public:
    VALUE convert(UserVariablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserVariablesContextProxy>(x, false, rb_cUserVariablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeclareVariableContext*> {
  public:
    VALUE convert(MySqlParser::DeclareVariableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeclareVariableContext>(x, false, rb_cDeclareVariableContext);
    }
  };

  template <>
  class To_Ruby<DeclareVariableContextProxy*> {
  public:
    VALUE convert(DeclareVariableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeclareVariableContextProxy>(x, false, rb_cDeclareVariableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeclareConditionContext*> {
  public:
    VALUE convert(MySqlParser::DeclareConditionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeclareConditionContext>(x, false, rb_cDeclareConditionContext);
    }
  };

  template <>
  class To_Ruby<DeclareConditionContextProxy*> {
  public:
    VALUE convert(DeclareConditionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeclareConditionContextProxy>(x, false, rb_cDeclareConditionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeclareCursorContext*> {
  public:
    VALUE convert(MySqlParser::DeclareCursorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeclareCursorContext>(x, false, rb_cDeclareCursorContext);
    }
  };

  template <>
  class To_Ruby<DeclareCursorContextProxy*> {
  public:
    VALUE convert(DeclareCursorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeclareCursorContextProxy>(x, false, rb_cDeclareCursorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DeclareHandlerContext*> {
  public:
    VALUE convert(MySqlParser::DeclareHandlerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DeclareHandlerContext>(x, false, rb_cDeclareHandlerContext);
    }
  };

  template <>
  class To_Ruby<DeclareHandlerContextProxy*> {
  public:
    VALUE convert(DeclareHandlerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DeclareHandlerContextProxy>(x, false, rb_cDeclareHandlerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ProcedureSqlStatementContext*> {
  public:
    VALUE convert(MySqlParser::ProcedureSqlStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ProcedureSqlStatementContext>(x, false, rb_cProcedureSqlStatementContext);
    }
  };

  template <>
  class To_Ruby<ProcedureSqlStatementContextProxy*> {
  public:
    VALUE convert(ProcedureSqlStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ProcedureSqlStatementContextProxy>(x, false, rb_cProcedureSqlStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CaseAlternativeContext*> {
  public:
    VALUE convert(MySqlParser::CaseAlternativeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CaseAlternativeContext>(x, false, rb_cCaseAlternativeContext);
    }
  };

  template <>
  class To_Ruby<CaseAlternativeContextProxy*> {
  public:
    VALUE convert(CaseAlternativeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CaseAlternativeContextProxy>(x, false, rb_cCaseAlternativeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ElifAlternativeContext*> {
  public:
    VALUE convert(MySqlParser::ElifAlternativeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ElifAlternativeContext>(x, false, rb_cElifAlternativeContext);
    }
  };

  template <>
  class To_Ruby<ElifAlternativeContextProxy*> {
  public:
    VALUE convert(ElifAlternativeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ElifAlternativeContextProxy>(x, false, rb_cElifAlternativeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CloseCursorContext*> {
  public:
    VALUE convert(MySqlParser::CloseCursorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CloseCursorContext>(x, false, rb_cCloseCursorContext);
    }
  };

  template <>
  class To_Ruby<CloseCursorContextProxy*> {
  public:
    VALUE convert(CloseCursorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CloseCursorContextProxy>(x, false, rb_cCloseCursorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OpenCursorContext*> {
  public:
    VALUE convert(MySqlParser::OpenCursorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OpenCursorContext>(x, false, rb_cOpenCursorContext);
    }
  };

  template <>
  class To_Ruby<OpenCursorContextProxy*> {
  public:
    VALUE convert(OpenCursorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OpenCursorContextProxy>(x, false, rb_cOpenCursorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FetchCursorContext*> {
  public:
    VALUE convert(MySqlParser::FetchCursorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FetchCursorContext>(x, false, rb_cFetchCursorContext);
    }
  };

  template <>
  class To_Ruby<FetchCursorContextProxy*> {
  public:
    VALUE convert(FetchCursorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FetchCursorContextProxy>(x, false, rb_cFetchCursorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionValueContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionValueContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionValueContext>(x, false, rb_cHandlerConditionValueContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionValueContextProxy*> {
  public:
    VALUE convert(HandlerConditionValueContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionValueContextProxy>(x, false, rb_cHandlerConditionValueContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionWarningContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionWarningContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionWarningContext>(x, false, rb_cHandlerConditionWarningContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionWarningContextProxy*> {
  public:
    VALUE convert(HandlerConditionWarningContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionWarningContextProxy>(x, false, rb_cHandlerConditionWarningContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionCodeContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionCodeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionCodeContext>(x, false, rb_cHandlerConditionCodeContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionCodeContextProxy*> {
  public:
    VALUE convert(HandlerConditionCodeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionCodeContextProxy>(x, false, rb_cHandlerConditionCodeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionNotfoundContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionNotfoundContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionNotfoundContext>(x, false, rb_cHandlerConditionNotfoundContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionNotfoundContextProxy*> {
  public:
    VALUE convert(HandlerConditionNotfoundContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionNotfoundContextProxy>(x, false, rb_cHandlerConditionNotfoundContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionStateContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionStateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionStateContext>(x, false, rb_cHandlerConditionStateContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionStateContextProxy*> {
  public:
    VALUE convert(HandlerConditionStateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionStateContextProxy>(x, false, rb_cHandlerConditionStateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionExceptionContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionExceptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionExceptionContext>(x, false, rb_cHandlerConditionExceptionContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionExceptionContextProxy*> {
  public:
    VALUE convert(HandlerConditionExceptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionExceptionContextProxy>(x, false, rb_cHandlerConditionExceptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HandlerConditionNameContext*> {
  public:
    VALUE convert(MySqlParser::HandlerConditionNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HandlerConditionNameContext>(x, false, rb_cHandlerConditionNameContext);
    }
  };

  template <>
  class To_Ruby<HandlerConditionNameContextProxy*> {
  public:
    VALUE convert(HandlerConditionNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HandlerConditionNameContextProxy>(x, false, rb_cHandlerConditionNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterUserMysqlV80Context*> {
  public:
    VALUE convert(MySqlParser::AlterUserMysqlV80Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterUserMysqlV80Context>(x, false, rb_cAlterUserMysqlV80Context);
    }
  };

  template <>
  class To_Ruby<AlterUserMysqlV80ContextProxy*> {
  public:
    VALUE convert(AlterUserMysqlV80ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterUserMysqlV80ContextProxy>(x, false, rb_cAlterUserMysqlV80Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::UserAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserAuthOptionContext>(x, false, rb_cUserAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<UserAuthOptionContextProxy*> {
  public:
    VALUE convert(UserAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserAuthOptionContextProxy>(x, false, rb_cUserAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserPasswordOptionContext*> {
  public:
    VALUE convert(MySqlParser::UserPasswordOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserPasswordOptionContext>(x, false, rb_cUserPasswordOptionContext);
    }
  };

  template <>
  class To_Ruby<UserPasswordOptionContextProxy*> {
  public:
    VALUE convert(UserPasswordOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserPasswordOptionContextProxy>(x, false, rb_cUserPasswordOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserLockOptionContext*> {
  public:
    VALUE convert(MySqlParser::UserLockOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserLockOptionContext>(x, false, rb_cUserLockOptionContext);
    }
  };

  template <>
  class To_Ruby<UserLockOptionContextProxy*> {
  public:
    VALUE convert(UserLockOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserLockOptionContextProxy>(x, false, rb_cUserLockOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TlsOptionContext*> {
  public:
    VALUE convert(MySqlParser::TlsOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TlsOptionContext>(x, false, rb_cTlsOptionContext);
    }
  };

  template <>
  class To_Ruby<TlsOptionContextProxy*> {
  public:
    VALUE convert(TlsOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TlsOptionContextProxy>(x, false, rb_cTlsOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserResourceOptionContext*> {
  public:
    VALUE convert(MySqlParser::UserResourceOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserResourceOptionContext>(x, false, rb_cUserResourceOptionContext);
    }
  };

  template <>
  class To_Ruby<UserResourceOptionContextProxy*> {
  public:
    VALUE convert(UserResourceOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserResourceOptionContextProxy>(x, false, rb_cUserResourceOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AlterUserMysqlV56Context*> {
  public:
    VALUE convert(MySqlParser::AlterUserMysqlV56Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AlterUserMysqlV56Context>(x, false, rb_cAlterUserMysqlV56Context);
    }
  };

  template <>
  class To_Ruby<AlterUserMysqlV56ContextProxy*> {
  public:
    VALUE convert(AlterUserMysqlV56ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AlterUserMysqlV56ContextProxy>(x, false, rb_cAlterUserMysqlV56Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UserSpecificationContext*> {
  public:
    VALUE convert(MySqlParser::UserSpecificationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UserSpecificationContext>(x, false, rb_cUserSpecificationContext);
    }
  };

  template <>
  class To_Ruby<UserSpecificationContextProxy*> {
  public:
    VALUE convert(UserSpecificationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UserSpecificationContextProxy>(x, false, rb_cUserSpecificationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateUserMysqlV56Context*> {
  public:
    VALUE convert(MySqlParser::CreateUserMysqlV56Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateUserMysqlV56Context>(x, false, rb_cCreateUserMysqlV56Context);
    }
  };

  template <>
  class To_Ruby<CreateUserMysqlV56ContextProxy*> {
  public:
    VALUE convert(CreateUserMysqlV56ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateUserMysqlV56ContextProxy>(x, false, rb_cCreateUserMysqlV56Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CreateUserMysqlV80Context*> {
  public:
    VALUE convert(MySqlParser::CreateUserMysqlV80Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CreateUserMysqlV80Context>(x, false, rb_cCreateUserMysqlV80Context);
    }
  };

  template <>
  class To_Ruby<CreateUserMysqlV80ContextProxy*> {
  public:
    VALUE convert(CreateUserMysqlV80ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CreateUserMysqlV80ContextProxy>(x, false, rb_cCreateUserMysqlV80Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrivelegeClauseContext*> {
  public:
    VALUE convert(MySqlParser::PrivelegeClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrivelegeClauseContext>(x, false, rb_cPrivelegeClauseContext);
    }
  };

  template <>
  class To_Ruby<PrivelegeClauseContextProxy*> {
  public:
    VALUE convert(PrivelegeClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrivelegeClauseContextProxy>(x, false, rb_cPrivelegeClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrivilegeLevelContext*> {
  public:
    VALUE convert(MySqlParser::PrivilegeLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrivilegeLevelContext>(x, false, rb_cPrivilegeLevelContext);
    }
  };

  template <>
  class To_Ruby<PrivilegeLevelContextProxy*> {
  public:
    VALUE convert(PrivilegeLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrivilegeLevelContextProxy>(x, false, rb_cPrivilegeLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RenameUserClauseContext*> {
  public:
    VALUE convert(MySqlParser::RenameUserClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RenameUserClauseContext>(x, false, rb_cRenameUserClauseContext);
    }
  };

  template <>
  class To_Ruby<RenameUserClauseContextProxy*> {
  public:
    VALUE convert(RenameUserClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RenameUserClauseContextProxy>(x, false, rb_cRenameUserClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DetailRevokeContext*> {
  public:
    VALUE convert(MySqlParser::DetailRevokeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DetailRevokeContext>(x, false, rb_cDetailRevokeContext);
    }
  };

  template <>
  class To_Ruby<DetailRevokeContextProxy*> {
  public:
    VALUE convert(DetailRevokeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DetailRevokeContextProxy>(x, false, rb_cDetailRevokeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RoleRevokeContext*> {
  public:
    VALUE convert(MySqlParser::RoleRevokeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RoleRevokeContext>(x, false, rb_cRoleRevokeContext);
    }
  };

  template <>
  class To_Ruby<RoleRevokeContextProxy*> {
  public:
    VALUE convert(RoleRevokeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RoleRevokeContextProxy>(x, false, rb_cRoleRevokeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShortRevokeContext*> {
  public:
    VALUE convert(MySqlParser::ShortRevokeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShortRevokeContext>(x, false, rb_cShortRevokeContext);
    }
  };

  template <>
  class To_Ruby<ShortRevokeContextProxy*> {
  public:
    VALUE convert(ShortRevokeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShortRevokeContextProxy>(x, false, rb_cShortRevokeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetPasswordStatementContext*> {
  public:
    VALUE convert(MySqlParser::SetPasswordStatementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetPasswordStatementContext>(x, false, rb_cSetPasswordStatementContext);
    }
  };

  template <>
  class To_Ruby<SetPasswordStatementContextProxy*> {
  public:
    VALUE convert(SetPasswordStatementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetPasswordStatementContextProxy>(x, false, rb_cSetPasswordStatementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PasswordFunctionClauseContext*> {
  public:
    VALUE convert(MySqlParser::PasswordFunctionClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PasswordFunctionClauseContext>(x, false, rb_cPasswordFunctionClauseContext);
    }
  };

  template <>
  class To_Ruby<PasswordFunctionClauseContextProxy*> {
  public:
    VALUE convert(PasswordFunctionClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PasswordFunctionClauseContextProxy>(x, false, rb_cPasswordFunctionClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::SimpleAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleAuthOptionContext>(x, false, rb_cSimpleAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<SimpleAuthOptionContextProxy*> {
  public:
    VALUE convert(SimpleAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleAuthOptionContextProxy>(x, false, rb_cSimpleAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ModuleAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::ModuleAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ModuleAuthOptionContext>(x, false, rb_cModuleAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<ModuleAuthOptionContextProxy*> {
  public:
    VALUE convert(ModuleAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ModuleAuthOptionContextProxy>(x, false, rb_cModuleAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AuthenticationRuleContext*> {
  public:
    VALUE convert(MySqlParser::AuthenticationRuleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AuthenticationRuleContext>(x, false, rb_cAuthenticationRuleContext);
    }
  };

  template <>
  class To_Ruby<AuthenticationRuleContextProxy*> {
  public:
    VALUE convert(AuthenticationRuleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AuthenticationRuleContextProxy>(x, false, rb_cAuthenticationRuleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RandomAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::RandomAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RandomAuthOptionContext>(x, false, rb_cRandomAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<RandomAuthOptionContextProxy*> {
  public:
    VALUE convert(RandomAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RandomAuthOptionContextProxy>(x, false, rb_cRandomAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AuthOptionClauseContext*> {
  public:
    VALUE convert(MySqlParser::AuthOptionClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AuthOptionClauseContext>(x, false, rb_cAuthOptionClauseContext);
    }
  };

  template <>
  class To_Ruby<AuthOptionClauseContextProxy*> {
  public:
    VALUE convert(AuthOptionClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AuthOptionClauseContextProxy>(x, false, rb_cAuthOptionClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StringAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::StringAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StringAuthOptionContext>(x, false, rb_cStringAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<StringAuthOptionContextProxy*> {
  public:
    VALUE convert(StringAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StringAuthOptionContextProxy>(x, false, rb_cStringAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HashAuthOptionContext*> {
  public:
    VALUE convert(MySqlParser::HashAuthOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HashAuthOptionContext>(x, false, rb_cHashAuthOptionContext);
    }
  };

  template <>
  class To_Ruby<HashAuthOptionContextProxy*> {
  public:
    VALUE convert(HashAuthOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HashAuthOptionContextProxy>(x, false, rb_cHashAuthOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AuthPluginContext*> {
  public:
    VALUE convert(MySqlParser::AuthPluginContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AuthPluginContext>(x, false, rb_cAuthPluginContext);
    }
  };

  template <>
  class To_Ruby<AuthPluginContextProxy*> {
  public:
    VALUE convert(AuthPluginContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AuthPluginContextProxy>(x, false, rb_cAuthPluginContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PasswordModuleOptionContext*> {
  public:
    VALUE convert(MySqlParser::PasswordModuleOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PasswordModuleOptionContext>(x, false, rb_cPasswordModuleOptionContext);
    }
  };

  template <>
  class To_Ruby<PasswordModuleOptionContextProxy*> {
  public:
    VALUE convert(PasswordModuleOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PasswordModuleOptionContextProxy>(x, false, rb_cPasswordModuleOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ModuleContext*> {
  public:
    VALUE convert(MySqlParser::ModuleContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ModuleContext>(x, false, rb_cModuleContext);
    }
  };

  template <>
  class To_Ruby<ModuleContextProxy*> {
  public:
    VALUE convert(ModuleContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ModuleContextProxy>(x, false, rb_cModuleContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrivilegeContext*> {
  public:
    VALUE convert(MySqlParser::PrivilegeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrivilegeContext>(x, false, rb_cPrivilegeContext);
    }
  };

  template <>
  class To_Ruby<PrivilegeContextProxy*> {
  public:
    VALUE convert(PrivilegeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrivilegeContextProxy>(x, false, rb_cPrivilegeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefiniteSchemaPrivLevelContext*> {
  public:
    VALUE convert(MySqlParser::DefiniteSchemaPrivLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefiniteSchemaPrivLevelContext>(x, false, rb_cDefiniteSchemaPrivLevelContext);
    }
  };

  template <>
  class To_Ruby<DefiniteSchemaPrivLevelContextProxy*> {
  public:
    VALUE convert(DefiniteSchemaPrivLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefiniteSchemaPrivLevelContextProxy>(x, false, rb_cDefiniteSchemaPrivLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefiniteFullTablePrivLevel2Context*> {
  public:
    VALUE convert(MySqlParser::DefiniteFullTablePrivLevel2Context* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefiniteFullTablePrivLevel2Context>(x, false, rb_cDefiniteFullTablePrivLevel2Context);
    }
  };

  template <>
  class To_Ruby<DefiniteFullTablePrivLevel2ContextProxy*> {
  public:
    VALUE convert(DefiniteFullTablePrivLevel2ContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefiniteFullTablePrivLevel2ContextProxy>(x, false, rb_cDefiniteFullTablePrivLevel2Context);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DottedIdContext*> {
  public:
    VALUE convert(MySqlParser::DottedIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DottedIdContext>(x, false, rb_cDottedIdContext);
    }
  };

  template <>
  class To_Ruby<DottedIdContextProxy*> {
  public:
    VALUE convert(DottedIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DottedIdContextProxy>(x, false, rb_cDottedIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefiniteFullTablePrivLevelContext*> {
  public:
    VALUE convert(MySqlParser::DefiniteFullTablePrivLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefiniteFullTablePrivLevelContext>(x, false, rb_cDefiniteFullTablePrivLevelContext);
    }
  };

  template <>
  class To_Ruby<DefiniteFullTablePrivLevelContextProxy*> {
  public:
    VALUE convert(DefiniteFullTablePrivLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefiniteFullTablePrivLevelContextProxy>(x, false, rb_cDefiniteFullTablePrivLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GlobalPrivLevelContext*> {
  public:
    VALUE convert(MySqlParser::GlobalPrivLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GlobalPrivLevelContext>(x, false, rb_cGlobalPrivLevelContext);
    }
  };

  template <>
  class To_Ruby<GlobalPrivLevelContextProxy*> {
  public:
    VALUE convert(GlobalPrivLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GlobalPrivLevelContextProxy>(x, false, rb_cGlobalPrivLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DefiniteTablePrivLevelContext*> {
  public:
    VALUE convert(MySqlParser::DefiniteTablePrivLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DefiniteTablePrivLevelContext>(x, false, rb_cDefiniteTablePrivLevelContext);
    }
  };

  template <>
  class To_Ruby<DefiniteTablePrivLevelContextProxy*> {
  public:
    VALUE convert(DefiniteTablePrivLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DefiniteTablePrivLevelContextProxy>(x, false, rb_cDefiniteTablePrivLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CurrentSchemaPriviLevelContext*> {
  public:
    VALUE convert(MySqlParser::CurrentSchemaPriviLevelContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CurrentSchemaPriviLevelContext>(x, false, rb_cCurrentSchemaPriviLevelContext);
    }
  };

  template <>
  class To_Ruby<CurrentSchemaPriviLevelContextProxy*> {
  public:
    VALUE convert(CurrentSchemaPriviLevelContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CurrentSchemaPriviLevelContextProxy>(x, false, rb_cCurrentSchemaPriviLevelContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CheckTableOptionContext*> {
  public:
    VALUE convert(MySqlParser::CheckTableOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CheckTableOptionContext>(x, false, rb_cCheckTableOptionContext);
    }
  };

  template <>
  class To_Ruby<CheckTableOptionContextProxy*> {
  public:
    VALUE convert(CheckTableOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CheckTableOptionContextProxy>(x, false, rb_cCheckTableOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetTransactionContext*> {
  public:
    VALUE convert(MySqlParser::SetTransactionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetTransactionContext>(x, false, rb_cSetTransactionContext);
    }
  };

  template <>
  class To_Ruby<SetTransactionContextProxy*> {
  public:
    VALUE convert(SetTransactionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetTransactionContextProxy>(x, false, rb_cSetTransactionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetCharsetContext*> {
  public:
    VALUE convert(MySqlParser::SetCharsetContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetCharsetContext>(x, false, rb_cSetCharsetContext);
    }
  };

  template <>
  class To_Ruby<SetCharsetContextProxy*> {
  public:
    VALUE convert(SetCharsetContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetCharsetContextProxy>(x, false, rb_cSetCharsetContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetNamesContext*> {
  public:
    VALUE convert(MySqlParser::SetNamesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetNamesContext>(x, false, rb_cSetNamesContext);
    }
  };

  template <>
  class To_Ruby<SetNamesContextProxy*> {
  public:
    VALUE convert(SetNamesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetNamesContextProxy>(x, false, rb_cSetNamesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetPasswordContext*> {
  public:
    VALUE convert(MySqlParser::SetPasswordContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetPasswordContext>(x, false, rb_cSetPasswordContext);
    }
  };

  template <>
  class To_Ruby<SetPasswordContextProxy*> {
  public:
    VALUE convert(SetPasswordContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetPasswordContextProxy>(x, false, rb_cSetPasswordContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetAutocommitContext*> {
  public:
    VALUE convert(MySqlParser::SetAutocommitContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetAutocommitContext>(x, false, rb_cSetAutocommitContext);
    }
  };

  template <>
  class To_Ruby<SetAutocommitContextProxy*> {
  public:
    VALUE convert(SetAutocommitContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetAutocommitContextProxy>(x, false, rb_cSetAutocommitContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetNewValueInsideTriggerContext*> {
  public:
    VALUE convert(MySqlParser::SetNewValueInsideTriggerContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetNewValueInsideTriggerContext>(x, false, rb_cSetNewValueInsideTriggerContext);
    }
  };

  template <>
  class To_Ruby<SetNewValueInsideTriggerContextProxy*> {
  public:
    VALUE convert(SetNewValueInsideTriggerContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetNewValueInsideTriggerContextProxy>(x, false, rb_cSetNewValueInsideTriggerContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SetVariableContext*> {
  public:
    VALUE convert(MySqlParser::SetVariableContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SetVariableContext>(x, false, rb_cSetVariableContext);
    }
  };

  template <>
  class To_Ruby<SetVariableContextProxy*> {
  public:
    VALUE convert(SetVariableContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SetVariableContextProxy>(x, false, rb_cSetVariableContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::VariableClauseContext*> {
  public:
    VALUE convert(MySqlParser::VariableClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::VariableClauseContext>(x, false, rb_cVariableClauseContext);
    }
  };

  template <>
  class To_Ruby<VariableClauseContextProxy*> {
  public:
    VALUE convert(VariableClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<VariableClauseContextProxy>(x, false, rb_cVariableClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowOpenTablesContext*> {
  public:
    VALUE convert(MySqlParser::ShowOpenTablesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowOpenTablesContext>(x, false, rb_cShowOpenTablesContext);
    }
  };

  template <>
  class To_Ruby<ShowOpenTablesContextProxy*> {
  public:
    VALUE convert(ShowOpenTablesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowOpenTablesContextProxy>(x, false, rb_cShowOpenTablesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowFilterContext*> {
  public:
    VALUE convert(MySqlParser::ShowFilterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowFilterContext>(x, false, rb_cShowFilterContext);
    }
  };

  template <>
  class To_Ruby<ShowFilterContextProxy*> {
  public:
    VALUE convert(ShowFilterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowFilterContextProxy>(x, false, rb_cShowFilterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowGlobalInfoContext*> {
  public:
    VALUE convert(MySqlParser::ShowGlobalInfoContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowGlobalInfoContext>(x, false, rb_cShowGlobalInfoContext);
    }
  };

  template <>
  class To_Ruby<ShowGlobalInfoContextProxy*> {
  public:
    VALUE convert(ShowGlobalInfoContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowGlobalInfoContextProxy>(x, false, rb_cShowGlobalInfoContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowGlobalInfoClauseContext*> {
  public:
    VALUE convert(MySqlParser::ShowGlobalInfoClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowGlobalInfoClauseContext>(x, false, rb_cShowGlobalInfoClauseContext);
    }
  };

  template <>
  class To_Ruby<ShowGlobalInfoClauseContextProxy*> {
  public:
    VALUE convert(ShowGlobalInfoClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowGlobalInfoClauseContextProxy>(x, false, rb_cShowGlobalInfoClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowCreateFullIdObjectContext*> {
  public:
    VALUE convert(MySqlParser::ShowCreateFullIdObjectContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowCreateFullIdObjectContext>(x, false, rb_cShowCreateFullIdObjectContext);
    }
  };

  template <>
  class To_Ruby<ShowCreateFullIdObjectContextProxy*> {
  public:
    VALUE convert(ShowCreateFullIdObjectContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowCreateFullIdObjectContextProxy>(x, false, rb_cShowCreateFullIdObjectContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowCreateUserContext*> {
  public:
    VALUE convert(MySqlParser::ShowCreateUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowCreateUserContext>(x, false, rb_cShowCreateUserContext);
    }
  };

  template <>
  class To_Ruby<ShowCreateUserContextProxy*> {
  public:
    VALUE convert(ShowCreateUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowCreateUserContextProxy>(x, false, rb_cShowCreateUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowErrorsContext*> {
  public:
    VALUE convert(MySqlParser::ShowErrorsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowErrorsContext>(x, false, rb_cShowErrorsContext);
    }
  };

  template <>
  class To_Ruby<ShowErrorsContextProxy*> {
  public:
    VALUE convert(ShowErrorsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowErrorsContextProxy>(x, false, rb_cShowErrorsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowCountErrorsContext*> {
  public:
    VALUE convert(MySqlParser::ShowCountErrorsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowCountErrorsContext>(x, false, rb_cShowCountErrorsContext);
    }
  };

  template <>
  class To_Ruby<ShowCountErrorsContextProxy*> {
  public:
    VALUE convert(ShowCountErrorsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowCountErrorsContextProxy>(x, false, rb_cShowCountErrorsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowObjectFilterContext*> {
  public:
    VALUE convert(MySqlParser::ShowObjectFilterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowObjectFilterContext>(x, false, rb_cShowObjectFilterContext);
    }
  };

  template <>
  class To_Ruby<ShowObjectFilterContextProxy*> {
  public:
    VALUE convert(ShowObjectFilterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowObjectFilterContextProxy>(x, false, rb_cShowObjectFilterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowCommonEntityContext*> {
  public:
    VALUE convert(MySqlParser::ShowCommonEntityContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowCommonEntityContext>(x, false, rb_cShowCommonEntityContext);
    }
  };

  template <>
  class To_Ruby<ShowCommonEntityContextProxy*> {
  public:
    VALUE convert(ShowCommonEntityContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowCommonEntityContextProxy>(x, false, rb_cShowCommonEntityContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowCreateDbContext*> {
  public:
    VALUE convert(MySqlParser::ShowCreateDbContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowCreateDbContext>(x, false, rb_cShowCreateDbContext);
    }
  };

  template <>
  class To_Ruby<ShowCreateDbContextProxy*> {
  public:
    VALUE convert(ShowCreateDbContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowCreateDbContextProxy>(x, false, rb_cShowCreateDbContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowEngineContext*> {
  public:
    VALUE convert(MySqlParser::ShowEngineContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowEngineContext>(x, false, rb_cShowEngineContext);
    }
  };

  template <>
  class To_Ruby<ShowEngineContextProxy*> {
  public:
    VALUE convert(ShowEngineContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowEngineContextProxy>(x, false, rb_cShowEngineContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowSchemaFilterContext*> {
  public:
    VALUE convert(MySqlParser::ShowSchemaFilterContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowSchemaFilterContext>(x, false, rb_cShowSchemaFilterContext);
    }
  };

  template <>
  class To_Ruby<ShowSchemaFilterContextProxy*> {
  public:
    VALUE convert(ShowSchemaFilterContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowSchemaFilterContextProxy>(x, false, rb_cShowSchemaFilterContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowSchemaEntityContext*> {
  public:
    VALUE convert(MySqlParser::ShowSchemaEntityContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowSchemaEntityContext>(x, false, rb_cShowSchemaEntityContext);
    }
  };

  template <>
  class To_Ruby<ShowSchemaEntityContextProxy*> {
  public:
    VALUE convert(ShowSchemaEntityContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowSchemaEntityContextProxy>(x, false, rb_cShowSchemaEntityContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowIndexesContext*> {
  public:
    VALUE convert(MySqlParser::ShowIndexesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowIndexesContext>(x, false, rb_cShowIndexesContext);
    }
  };

  template <>
  class To_Ruby<ShowIndexesContextProxy*> {
  public:
    VALUE convert(ShowIndexesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowIndexesContextProxy>(x, false, rb_cShowIndexesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowLogEventsContext*> {
  public:
    VALUE convert(MySqlParser::ShowLogEventsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowLogEventsContext>(x, false, rb_cShowLogEventsContext);
    }
  };

  template <>
  class To_Ruby<ShowLogEventsContextProxy*> {
  public:
    VALUE convert(ShowLogEventsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowLogEventsContextProxy>(x, false, rb_cShowLogEventsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowMasterLogsContext*> {
  public:
    VALUE convert(MySqlParser::ShowMasterLogsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowMasterLogsContext>(x, false, rb_cShowMasterLogsContext);
    }
  };

  template <>
  class To_Ruby<ShowMasterLogsContextProxy*> {
  public:
    VALUE convert(ShowMasterLogsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowMasterLogsContextProxy>(x, false, rb_cShowMasterLogsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowGrantsContext*> {
  public:
    VALUE convert(MySqlParser::ShowGrantsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowGrantsContext>(x, false, rb_cShowGrantsContext);
    }
  };

  template <>
  class To_Ruby<ShowGrantsContextProxy*> {
  public:
    VALUE convert(ShowGrantsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowGrantsContextProxy>(x, false, rb_cShowGrantsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowSlaveStatusContext*> {
  public:
    VALUE convert(MySqlParser::ShowSlaveStatusContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowSlaveStatusContext>(x, false, rb_cShowSlaveStatusContext);
    }
  };

  template <>
  class To_Ruby<ShowSlaveStatusContextProxy*> {
  public:
    VALUE convert(ShowSlaveStatusContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowSlaveStatusContextProxy>(x, false, rb_cShowSlaveStatusContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowRoutineContext*> {
  public:
    VALUE convert(MySqlParser::ShowRoutineContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowRoutineContext>(x, false, rb_cShowRoutineContext);
    }
  };

  template <>
  class To_Ruby<ShowRoutineContextProxy*> {
  public:
    VALUE convert(ShowRoutineContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowRoutineContextProxy>(x, false, rb_cShowRoutineContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowProfileContext*> {
  public:
    VALUE convert(MySqlParser::ShowProfileContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowProfileContext>(x, false, rb_cShowProfileContext);
    }
  };

  template <>
  class To_Ruby<ShowProfileContextProxy*> {
  public:
    VALUE convert(ShowProfileContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowProfileContextProxy>(x, false, rb_cShowProfileContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowProfileTypeContext*> {
  public:
    VALUE convert(MySqlParser::ShowProfileTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowProfileTypeContext>(x, false, rb_cShowProfileTypeContext);
    }
  };

  template <>
  class To_Ruby<ShowProfileTypeContextProxy*> {
  public:
    VALUE convert(ShowProfileTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowProfileTypeContextProxy>(x, false, rb_cShowProfileTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ShowColumnsContext*> {
  public:
    VALUE convert(MySqlParser::ShowColumnsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ShowColumnsContext>(x, false, rb_cShowColumnsContext);
    }
  };

  template <>
  class To_Ruby<ShowColumnsContextProxy*> {
  public:
    VALUE convert(ShowColumnsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ShowColumnsContextProxy>(x, false, rb_cShowColumnsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableIndexesContext*> {
  public:
    VALUE convert(MySqlParser::TableIndexesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableIndexesContext>(x, false, rb_cTableIndexesContext);
    }
  };

  template <>
  class To_Ruby<TableIndexesContextProxy*> {
  public:
    VALUE convert(TableIndexesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableIndexesContextProxy>(x, false, rb_cTableIndexesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FlushOptionContext*> {
  public:
    VALUE convert(MySqlParser::FlushOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FlushOptionContext>(x, false, rb_cFlushOptionContext);
    }
  };

  template <>
  class To_Ruby<FlushOptionContextProxy*> {
  public:
    VALUE convert(FlushOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FlushOptionContextProxy>(x, false, rb_cFlushOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LoadedTableIndexesContext*> {
  public:
    VALUE convert(MySqlParser::LoadedTableIndexesContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LoadedTableIndexesContext>(x, false, rb_cLoadedTableIndexesContext);
    }
  };

  template <>
  class To_Ruby<LoadedTableIndexesContextProxy*> {
  public:
    VALUE convert(LoadedTableIndexesContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LoadedTableIndexesContextProxy>(x, false, rb_cLoadedTableIndexesContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TableFlushOptionContext*> {
  public:
    VALUE convert(MySqlParser::TableFlushOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TableFlushOptionContext>(x, false, rb_cTableFlushOptionContext);
    }
  };

  template <>
  class To_Ruby<TableFlushOptionContextProxy*> {
  public:
    VALUE convert(TableFlushOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TableFlushOptionContextProxy>(x, false, rb_cTableFlushOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FlushTableOptionContext*> {
  public:
    VALUE convert(MySqlParser::FlushTableOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FlushTableOptionContext>(x, false, rb_cFlushTableOptionContext);
    }
  };

  template <>
  class To_Ruby<FlushTableOptionContextProxy*> {
  public:
    VALUE convert(FlushTableOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FlushTableOptionContextProxy>(x, false, rb_cFlushTableOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ChannelFlushOptionContext*> {
  public:
    VALUE convert(MySqlParser::ChannelFlushOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ChannelFlushOptionContext>(x, false, rb_cChannelFlushOptionContext);
    }
  };

  template <>
  class To_Ruby<ChannelFlushOptionContextProxy*> {
  public:
    VALUE convert(ChannelFlushOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ChannelFlushOptionContextProxy>(x, false, rb_cChannelFlushOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleFlushOptionContext*> {
  public:
    VALUE convert(MySqlParser::SimpleFlushOptionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleFlushOptionContext>(x, false, rb_cSimpleFlushOptionContext);
    }
  };

  template <>
  class To_Ruby<SimpleFlushOptionContextProxy*> {
  public:
    VALUE convert(SimpleFlushOptionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleFlushOptionContextProxy>(x, false, rb_cSimpleFlushOptionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DescribeObjectClauseContext*> {
  public:
    VALUE convert(MySqlParser::DescribeObjectClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DescribeObjectClauseContext>(x, false, rb_cDescribeObjectClauseContext);
    }
  };

  template <>
  class To_Ruby<DescribeObjectClauseContextProxy*> {
  public:
    VALUE convert(DescribeObjectClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DescribeObjectClauseContextProxy>(x, false, rb_cDescribeObjectClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SignalConditionInformationContext*> {
  public:
    VALUE convert(MySqlParser::SignalConditionInformationContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SignalConditionInformationContext>(x, false, rb_cSignalConditionInformationContext);
    }
  };

  template <>
  class To_Ruby<SignalConditionInformationContextProxy*> {
  public:
    VALUE convert(SignalConditionInformationContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SignalConditionInformationContextProxy>(x, false, rb_cSignalConditionInformationContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DiagnosticsConditionInformationNameContext*> {
  public:
    VALUE convert(MySqlParser::DiagnosticsConditionInformationNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DiagnosticsConditionInformationNameContext>(x, false, rb_cDiagnosticsConditionInformationNameContext);
    }
  };

  template <>
  class To_Ruby<DiagnosticsConditionInformationNameContextProxy*> {
  public:
    VALUE convert(DiagnosticsConditionInformationNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DiagnosticsConditionInformationNameContextProxy>(x, false, rb_cDiagnosticsConditionInformationNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DescribeStatementsContext*> {
  public:
    VALUE convert(MySqlParser::DescribeStatementsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DescribeStatementsContext>(x, false, rb_cDescribeStatementsContext);
    }
  };

  template <>
  class To_Ruby<DescribeStatementsContextProxy*> {
  public:
    VALUE convert(DescribeStatementsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DescribeStatementsContextProxy>(x, false, rb_cDescribeStatementsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DescribeConnectionContext*> {
  public:
    VALUE convert(MySqlParser::DescribeConnectionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DescribeConnectionContext>(x, false, rb_cDescribeConnectionContext);
    }
  };

  template <>
  class To_Ruby<DescribeConnectionContextProxy*> {
  public:
    VALUE convert(DescribeConnectionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DescribeConnectionContextProxy>(x, false, rb_cDescribeConnectionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IndexColumnNameContext*> {
  public:
    VALUE convert(MySqlParser::IndexColumnNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IndexColumnNameContext>(x, false, rb_cIndexColumnNameContext);
    }
  };

  template <>
  class To_Ruby<IndexColumnNameContextProxy*> {
  public:
    VALUE convert(IndexColumnNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IndexColumnNameContextProxy>(x, false, rb_cIndexColumnNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleUserNameContext*> {
  public:
    VALUE convert(MySqlParser::SimpleUserNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleUserNameContext>(x, false, rb_cSimpleUserNameContext);
    }
  };

  template <>
  class To_Ruby<SimpleUserNameContextProxy*> {
  public:
    VALUE convert(SimpleUserNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleUserNameContextProxy>(x, false, rb_cSimpleUserNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::KeywordsCanBeIdContext*> {
  public:
    VALUE convert(MySqlParser::KeywordsCanBeIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::KeywordsCanBeIdContext>(x, false, rb_cKeywordsCanBeIdContext);
    }
  };

  template <>
  class To_Ruby<KeywordsCanBeIdContextProxy*> {
  public:
    VALUE convert(KeywordsCanBeIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<KeywordsCanBeIdContextProxy>(x, false, rb_cKeywordsCanBeIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HostNameContext*> {
  public:
    VALUE convert(MySqlParser::HostNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HostNameContext>(x, false, rb_cHostNameContext);
    }
  };

  template <>
  class To_Ruby<HostNameContextProxy*> {
  public:
    VALUE convert(HostNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HostNameContextProxy>(x, false, rb_cHostNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CharsetNameBaseContext*> {
  public:
    VALUE convert(MySqlParser::CharsetNameBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CharsetNameBaseContext>(x, false, rb_cCharsetNameBaseContext);
    }
  };

  template <>
  class To_Ruby<CharsetNameBaseContextProxy*> {
  public:
    VALUE convert(CharsetNameBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CharsetNameBaseContextProxy>(x, false, rb_cCharsetNameBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::EngineNameBaseContext*> {
  public:
    VALUE convert(MySqlParser::EngineNameBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::EngineNameBaseContext>(x, false, rb_cEngineNameBaseContext);
    }
  };

  template <>
  class To_Ruby<EngineNameBaseContextProxy*> {
  public:
    VALUE convert(EngineNameBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<EngineNameBaseContextProxy>(x, false, rb_cEngineNameBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::XuidStringIdContext*> {
  public:
    VALUE convert(MySqlParser::XuidStringIdContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::XuidStringIdContext>(x, false, rb_cXuidStringIdContext);
    }
  };

  template <>
  class To_Ruby<XuidStringIdContextProxy*> {
  public:
    VALUE convert(XuidStringIdContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<XuidStringIdContextProxy>(x, false, rb_cXuidStringIdContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TransactionLevelBaseContext*> {
  public:
    VALUE convert(MySqlParser::TransactionLevelBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TransactionLevelBaseContext>(x, false, rb_cTransactionLevelBaseContext);
    }
  };

  template <>
  class To_Ruby<TransactionLevelBaseContextProxy*> {
  public:
    VALUE convert(TransactionLevelBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TransactionLevelBaseContextProxy>(x, false, rb_cTransactionLevelBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PrivilegesBaseContext*> {
  public:
    VALUE convert(MySqlParser::PrivilegesBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PrivilegesBaseContext>(x, false, rb_cPrivilegesBaseContext);
    }
  };

  template <>
  class To_Ruby<PrivilegesBaseContextProxy*> {
  public:
    VALUE convert(PrivilegesBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PrivilegesBaseContextProxy>(x, false, rb_cPrivilegesBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DataTypeBaseContext*> {
  public:
    VALUE convert(MySqlParser::DataTypeBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DataTypeBaseContext>(x, false, rb_cDataTypeBaseContext);
    }
  };

  template <>
  class To_Ruby<DataTypeBaseContextProxy*> {
  public:
    VALUE convert(DataTypeBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DataTypeBaseContextProxy>(x, false, rb_cDataTypeBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ScalarFunctionNameContext*> {
  public:
    VALUE convert(MySqlParser::ScalarFunctionNameContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ScalarFunctionNameContext>(x, false, rb_cScalarFunctionNameContext);
    }
  };

  template <>
  class To_Ruby<ScalarFunctionNameContextProxy*> {
  public:
    VALUE convert(ScalarFunctionNameContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ScalarFunctionNameContextProxy>(x, false, rb_cScalarFunctionNameContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BooleanLiteralContext*> {
  public:
    VALUE convert(MySqlParser::BooleanLiteralContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BooleanLiteralContext>(x, false, rb_cBooleanLiteralContext);
    }
  };

  template <>
  class To_Ruby<BooleanLiteralContextProxy*> {
  public:
    VALUE convert(BooleanLiteralContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BooleanLiteralContextProxy>(x, false, rb_cBooleanLiteralContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::HexadecimalLiteralContext*> {
  public:
    VALUE convert(MySqlParser::HexadecimalLiteralContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::HexadecimalLiteralContext>(x, false, rb_cHexadecimalLiteralContext);
    }
  };

  template <>
  class To_Ruby<HexadecimalLiteralContextProxy*> {
  public:
    VALUE convert(HexadecimalLiteralContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<HexadecimalLiteralContextProxy>(x, false, rb_cHexadecimalLiteralContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SpatialDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::SpatialDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SpatialDataTypeContext>(x, false, rb_cSpatialDataTypeContext);
    }
  };

  template <>
  class To_Ruby<SpatialDataTypeContextProxy*> {
  public:
    VALUE convert(SpatialDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SpatialDataTypeContextProxy>(x, false, rb_cSpatialDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LongVarbinaryDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::LongVarbinaryDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LongVarbinaryDataTypeContext>(x, false, rb_cLongVarbinaryDataTypeContext);
    }
  };

  template <>
  class To_Ruby<LongVarbinaryDataTypeContextProxy*> {
  public:
    VALUE convert(LongVarbinaryDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LongVarbinaryDataTypeContextProxy>(x, false, rb_cLongVarbinaryDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CollectionOptionsContext*> {
  public:
    VALUE convert(MySqlParser::CollectionOptionsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CollectionOptionsContext>(x, false, rb_cCollectionOptionsContext);
    }
  };

  template <>
  class To_Ruby<CollectionOptionsContextProxy*> {
  public:
    VALUE convert(CollectionOptionsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CollectionOptionsContextProxy>(x, false, rb_cCollectionOptionsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CollectionDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::CollectionDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CollectionDataTypeContext>(x, false, rb_cCollectionDataTypeContext);
    }
  };

  template <>
  class To_Ruby<CollectionDataTypeContextProxy*> {
  public:
    VALUE convert(CollectionDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CollectionDataTypeContextProxy>(x, false, rb_cCollectionDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NationalVaryingStringDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::NationalVaryingStringDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NationalVaryingStringDataTypeContext>(x, false, rb_cNationalVaryingStringDataTypeContext);
    }
  };

  template <>
  class To_Ruby<NationalVaryingStringDataTypeContextProxy*> {
  public:
    VALUE convert(NationalVaryingStringDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NationalVaryingStringDataTypeContextProxy>(x, false, rb_cNationalVaryingStringDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LengthOneDimensionContext*> {
  public:
    VALUE convert(MySqlParser::LengthOneDimensionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LengthOneDimensionContext>(x, false, rb_cLengthOneDimensionContext);
    }
  };

  template <>
  class To_Ruby<LengthOneDimensionContextProxy*> {
  public:
    VALUE convert(LengthOneDimensionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LengthOneDimensionContextProxy>(x, false, rb_cLengthOneDimensionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DimensionDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::DimensionDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DimensionDataTypeContext>(x, false, rb_cDimensionDataTypeContext);
    }
  };

  template <>
  class To_Ruby<DimensionDataTypeContextProxy*> {
  public:
    VALUE convert(DimensionDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DimensionDataTypeContextProxy>(x, false, rb_cDimensionDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LengthTwoDimensionContext*> {
  public:
    VALUE convert(MySqlParser::LengthTwoDimensionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LengthTwoDimensionContext>(x, false, rb_cLengthTwoDimensionContext);
    }
  };

  template <>
  class To_Ruby<LengthTwoDimensionContextProxy*> {
  public:
    VALUE convert(LengthTwoDimensionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LengthTwoDimensionContextProxy>(x, false, rb_cLengthTwoDimensionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LengthTwoOptionalDimensionContext*> {
  public:
    VALUE convert(MySqlParser::LengthTwoOptionalDimensionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LengthTwoOptionalDimensionContext>(x, false, rb_cLengthTwoOptionalDimensionContext);
    }
  };

  template <>
  class To_Ruby<LengthTwoOptionalDimensionContextProxy*> {
  public:
    VALUE convert(LengthTwoOptionalDimensionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LengthTwoOptionalDimensionContextProxy>(x, false, rb_cLengthTwoOptionalDimensionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::StringDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::StringDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::StringDataTypeContext>(x, false, rb_cStringDataTypeContext);
    }
  };

  template <>
  class To_Ruby<StringDataTypeContextProxy*> {
  public:
    VALUE convert(StringDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<StringDataTypeContextProxy>(x, false, rb_cStringDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LongVarcharDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::LongVarcharDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LongVarcharDataTypeContext>(x, false, rb_cLongVarcharDataTypeContext);
    }
  };

  template <>
  class To_Ruby<LongVarcharDataTypeContextProxy*> {
  public:
    VALUE convert(LongVarcharDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LongVarcharDataTypeContextProxy>(x, false, rb_cLongVarcharDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NationalStringDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::NationalStringDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NationalStringDataTypeContext>(x, false, rb_cNationalStringDataTypeContext);
    }
  };

  template <>
  class To_Ruby<NationalStringDataTypeContextProxy*> {
  public:
    VALUE convert(NationalStringDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NationalStringDataTypeContextProxy>(x, false, rb_cNationalStringDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::SimpleDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleDataTypeContext>(x, false, rb_cSimpleDataTypeContext);
    }
  };

  template <>
  class To_Ruby<SimpleDataTypeContextProxy*> {
  public:
    VALUE convert(SimpleDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleDataTypeContextProxy>(x, false, rb_cSimpleDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConvertedDataTypeContext*> {
  public:
    VALUE convert(MySqlParser::ConvertedDataTypeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConvertedDataTypeContext>(x, false, rb_cConvertedDataTypeContext);
    }
  };

  template <>
  class To_Ruby<ConvertedDataTypeContextProxy*> {
  public:
    VALUE convert(ConvertedDataTypeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConvertedDataTypeContextProxy>(x, false, rb_cConvertedDataTypeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionOrDefaultContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionOrDefaultContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionOrDefaultContext>(x, false, rb_cExpressionOrDefaultContext);
    }
  };

  template <>
  class To_Ruby<ExpressionOrDefaultContextProxy*> {
  public:
    VALUE convert(ExpressionOrDefaultContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionOrDefaultContextProxy>(x, false, rb_cExpressionOrDefaultContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnaryOperatorContext*> {
  public:
    VALUE convert(MySqlParser::UnaryOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnaryOperatorContext>(x, false, rb_cUnaryOperatorContext);
    }
  };

  template <>
  class To_Ruby<UnaryOperatorContextProxy*> {
  public:
    VALUE convert(UnaryOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnaryOperatorContextProxy>(x, false, rb_cUnaryOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SpecificFunctionContext*> {
  public:
    VALUE convert(MySqlParser::SpecificFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SpecificFunctionContext>(x, false, rb_cSpecificFunctionContext);
    }
  };

  template <>
  class To_Ruby<SpecificFunctionContextProxy*> {
  public:
    VALUE convert(SpecificFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SpecificFunctionContextProxy>(x, false, rb_cSpecificFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SpecificFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::SpecificFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SpecificFunctionCallContext>(x, false, rb_cSpecificFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<SpecificFunctionCallContextProxy*> {
  public:
    VALUE convert(SpecificFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SpecificFunctionCallContextProxy>(x, false, rb_cSpecificFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PasswordFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::PasswordFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PasswordFunctionCallContext>(x, false, rb_cPasswordFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<PasswordFunctionCallContextProxy*> {
  public:
    VALUE convert(PasswordFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PasswordFunctionCallContextProxy>(x, false, rb_cPasswordFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UdfFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::UdfFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UdfFunctionCallContext>(x, false, rb_cUdfFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<UdfFunctionCallContextProxy*> {
  public:
    VALUE convert(UdfFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UdfFunctionCallContextProxy>(x, false, rb_cUdfFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionArgsContext*> {
  public:
    VALUE convert(MySqlParser::FunctionArgsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionArgsContext>(x, false, rb_cFunctionArgsContext);
    }
  };

  template <>
  class To_Ruby<FunctionArgsContextProxy*> {
  public:
    VALUE convert(FunctionArgsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionArgsContextProxy>(x, false, rb_cFunctionArgsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NonAggregateWindowedFunctionContext*> {
  public:
    VALUE convert(MySqlParser::NonAggregateWindowedFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NonAggregateWindowedFunctionContext>(x, false, rb_cNonAggregateWindowedFunctionContext);
    }
  };

  template <>
  class To_Ruby<NonAggregateWindowedFunctionContextProxy*> {
  public:
    VALUE convert(NonAggregateWindowedFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NonAggregateWindowedFunctionContextProxy>(x, false, rb_cNonAggregateWindowedFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NonAggregateFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::NonAggregateFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NonAggregateFunctionCallContext>(x, false, rb_cNonAggregateFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<NonAggregateFunctionCallContextProxy*> {
  public:
    VALUE convert(NonAggregateFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NonAggregateFunctionCallContextProxy>(x, false, rb_cNonAggregateFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AggregateWindowedFunctionContext*> {
  public:
    VALUE convert(MySqlParser::AggregateWindowedFunctionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AggregateWindowedFunctionContext>(x, false, rb_cAggregateWindowedFunctionContext);
    }
  };

  template <>
  class To_Ruby<AggregateWindowedFunctionContextProxy*> {
  public:
    VALUE convert(AggregateWindowedFunctionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AggregateWindowedFunctionContextProxy>(x, false, rb_cAggregateWindowedFunctionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AggregateFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::AggregateFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AggregateFunctionCallContext>(x, false, rb_cAggregateFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<AggregateFunctionCallContextProxy*> {
  public:
    VALUE convert(AggregateFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AggregateFunctionCallContextProxy>(x, false, rb_cAggregateFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ScalarFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::ScalarFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ScalarFunctionCallContext>(x, false, rb_cScalarFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<ScalarFunctionCallContextProxy*> {
  public:
    VALUE convert(ScalarFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ScalarFunctionCallContextProxy>(x, false, rb_cScalarFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PositionFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::PositionFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PositionFunctionCallContext>(x, false, rb_cPositionFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<PositionFunctionCallContextProxy*> {
  public:
    VALUE convert(PositionFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PositionFunctionCallContextProxy>(x, false, rb_cPositionFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::TrimFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::TrimFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::TrimFunctionCallContext>(x, false, rb_cTrimFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<TrimFunctionCallContextProxy*> {
  public:
    VALUE convert(TrimFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<TrimFunctionCallContextProxy>(x, false, rb_cTrimFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonValueFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::JsonValueFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonValueFunctionCallContext>(x, false, rb_cJsonValueFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<JsonValueFunctionCallContextProxy*> {
  public:
    VALUE convert(JsonValueFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonValueFunctionCallContextProxy>(x, false, rb_cJsonValueFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CaseFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::CaseFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CaseFunctionCallContext>(x, false, rb_cCaseFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<CaseFunctionCallContextProxy*> {
  public:
    VALUE convert(CaseFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CaseFunctionCallContextProxy>(x, false, rb_cCaseFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CaseFuncAlternativeContext*> {
  public:
    VALUE convert(MySqlParser::CaseFuncAlternativeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CaseFuncAlternativeContext>(x, false, rb_cCaseFuncAlternativeContext);
    }
  };

  template <>
  class To_Ruby<CaseFuncAlternativeContextProxy*> {
  public:
    VALUE convert(CaseFuncAlternativeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CaseFuncAlternativeContextProxy>(x, false, rb_cCaseFuncAlternativeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionArgContext*> {
  public:
    VALUE convert(MySqlParser::FunctionArgContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionArgContext>(x, false, rb_cFunctionArgContext);
    }
  };

  template <>
  class To_Ruby<FunctionArgContextProxy*> {
  public:
    VALUE convert(FunctionArgContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionArgContextProxy>(x, false, rb_cFunctionArgContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExtractFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::ExtractFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExtractFunctionCallContext>(x, false, rb_cExtractFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<ExtractFunctionCallContextProxy*> {
  public:
    VALUE convert(ExtractFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExtractFunctionCallContextProxy>(x, false, rb_cExtractFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::DataTypeFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::DataTypeFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::DataTypeFunctionCallContext>(x, false, rb_cDataTypeFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<DataTypeFunctionCallContextProxy*> {
  public:
    VALUE convert(DataTypeFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<DataTypeFunctionCallContextProxy>(x, false, rb_cDataTypeFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ValuesFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::ValuesFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ValuesFunctionCallContext>(x, false, rb_cValuesFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<ValuesFunctionCallContextProxy*> {
  public:
    VALUE convert(ValuesFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ValuesFunctionCallContextProxy>(x, false, rb_cValuesFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CaseExpressionFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::CaseExpressionFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CaseExpressionFunctionCallContext>(x, false, rb_cCaseExpressionFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<CaseExpressionFunctionCallContextProxy*> {
  public:
    VALUE convert(CaseExpressionFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CaseExpressionFunctionCallContextProxy>(x, false, rb_cCaseExpressionFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CurrentUserContext*> {
  public:
    VALUE convert(MySqlParser::CurrentUserContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CurrentUserContext>(x, false, rb_cCurrentUserContext);
    }
  };

  template <>
  class To_Ruby<CurrentUserContextProxy*> {
  public:
    VALUE convert(CurrentUserContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CurrentUserContextProxy>(x, false, rb_cCurrentUserContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SimpleFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::SimpleFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SimpleFunctionCallContext>(x, false, rb_cSimpleFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<SimpleFunctionCallContextProxy*> {
  public:
    VALUE convert(SimpleFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SimpleFunctionCallContextProxy>(x, false, rb_cSimpleFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CharFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::CharFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CharFunctionCallContext>(x, false, rb_cCharFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<CharFunctionCallContextProxy*> {
  public:
    VALUE convert(CharFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CharFunctionCallContextProxy>(x, false, rb_cCharFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::WeightFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::WeightFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::WeightFunctionCallContext>(x, false, rb_cWeightFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<WeightFunctionCallContextProxy*> {
  public:
    VALUE convert(WeightFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<WeightFunctionCallContextProxy>(x, false, rb_cWeightFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LevelsInWeightStringContext*> {
  public:
    VALUE convert(MySqlParser::LevelsInWeightStringContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LevelsInWeightStringContext>(x, false, rb_cLevelsInWeightStringContext);
    }
  };

  template <>
  class To_Ruby<LevelsInWeightStringContextProxy*> {
  public:
    VALUE convert(LevelsInWeightStringContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LevelsInWeightStringContextProxy>(x, false, rb_cLevelsInWeightStringContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::GetFormatFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::GetFormatFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::GetFormatFunctionCallContext>(x, false, rb_cGetFormatFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<GetFormatFunctionCallContextProxy*> {
  public:
    VALUE convert(GetFormatFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<GetFormatFunctionCallContextProxy>(x, false, rb_cGetFormatFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubstrFunctionCallContext*> {
  public:
    VALUE convert(MySqlParser::SubstrFunctionCallContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubstrFunctionCallContext>(x, false, rb_cSubstrFunctionCallContext);
    }
  };

  template <>
  class To_Ruby<SubstrFunctionCallContextProxy*> {
  public:
    VALUE convert(SubstrFunctionCallContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubstrFunctionCallContextProxy>(x, false, rb_cSubstrFunctionCallContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LevelWeightRangeContext*> {
  public:
    VALUE convert(MySqlParser::LevelWeightRangeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LevelWeightRangeContext>(x, false, rb_cLevelWeightRangeContext);
    }
  };

  template <>
  class To_Ruby<LevelWeightRangeContextProxy*> {
  public:
    VALUE convert(LevelWeightRangeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LevelWeightRangeContextProxy>(x, false, rb_cLevelWeightRangeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LevelWeightListContext*> {
  public:
    VALUE convert(MySqlParser::LevelWeightListContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LevelWeightListContext>(x, false, rb_cLevelWeightListContext);
    }
  };

  template <>
  class To_Ruby<LevelWeightListContextProxy*> {
  public:
    VALUE convert(LevelWeightListContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LevelWeightListContextProxy>(x, false, rb_cLevelWeightListContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LevelInWeightListElementContext*> {
  public:
    VALUE convert(MySqlParser::LevelInWeightListElementContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LevelInWeightListElementContext>(x, false, rb_cLevelInWeightListElementContext);
    }
  };

  template <>
  class To_Ruby<LevelInWeightListElementContextProxy*> {
  public:
    VALUE convert(LevelInWeightListElementContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LevelInWeightListElementContextProxy>(x, false, rb_cLevelInWeightListElementContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::OverClauseContext*> {
  public:
    VALUE convert(MySqlParser::OverClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::OverClauseContext>(x, false, rb_cOverClauseContext);
    }
  };

  template <>
  class To_Ruby<OverClauseContextProxy*> {
  public:
    VALUE convert(OverClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<OverClauseContextProxy>(x, false, rb_cOverClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PartitionClauseContext*> {
  public:
    VALUE convert(MySqlParser::PartitionClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PartitionClauseContext>(x, false, rb_cPartitionClauseContext);
    }
  };

  template <>
  class To_Ruby<PartitionClauseContextProxy*> {
  public:
    VALUE convert(PartitionClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PartitionClauseContextProxy>(x, false, rb_cPartitionClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FrameClauseContext*> {
  public:
    VALUE convert(MySqlParser::FrameClauseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FrameClauseContext>(x, false, rb_cFrameClauseContext);
    }
  };

  template <>
  class To_Ruby<FrameClauseContextProxy*> {
  public:
    VALUE convert(FrameClauseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FrameClauseContextProxy>(x, false, rb_cFrameClauseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FrameUnitsContext*> {
  public:
    VALUE convert(MySqlParser::FrameUnitsContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FrameUnitsContext>(x, false, rb_cFrameUnitsContext);
    }
  };

  template <>
  class To_Ruby<FrameUnitsContextProxy*> {
  public:
    VALUE convert(FrameUnitsContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FrameUnitsContextProxy>(x, false, rb_cFrameUnitsContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FrameExtentContext*> {
  public:
    VALUE convert(MySqlParser::FrameExtentContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FrameExtentContext>(x, false, rb_cFrameExtentContext);
    }
  };

  template <>
  class To_Ruby<FrameExtentContextProxy*> {
  public:
    VALUE convert(FrameExtentContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FrameExtentContextProxy>(x, false, rb_cFrameExtentContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FrameRangeContext*> {
  public:
    VALUE convert(MySqlParser::FrameRangeContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FrameRangeContext>(x, false, rb_cFrameRangeContext);
    }
  };

  template <>
  class To_Ruby<FrameRangeContextProxy*> {
  public:
    VALUE convert(FrameRangeContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FrameRangeContextProxy>(x, false, rb_cFrameRangeContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FrameBetweenContext*> {
  public:
    VALUE convert(MySqlParser::FrameBetweenContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FrameBetweenContext>(x, false, rb_cFrameBetweenContext);
    }
  };

  template <>
  class To_Ruby<FrameBetweenContextProxy*> {
  public:
    VALUE convert(FrameBetweenContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FrameBetweenContextProxy>(x, false, rb_cFrameBetweenContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionNameBaseContext*> {
  public:
    VALUE convert(MySqlParser::FunctionNameBaseContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionNameBaseContext>(x, false, rb_cFunctionNameBaseContext);
    }
  };

  template <>
  class To_Ruby<FunctionNameBaseContextProxy*> {
  public:
    VALUE convert(FunctionNameBaseContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionNameBaseContextProxy>(x, false, rb_cFunctionNameBaseContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PredicateContext*> {
  public:
    VALUE convert(MySqlParser::PredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PredicateContext>(x, false, rb_cPredicateContext);
    }
  };

  template <>
  class To_Ruby<PredicateContextProxy*> {
  public:
    VALUE convert(PredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PredicateContextProxy>(x, false, rb_cPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IsExpressionContext*> {
  public:
    VALUE convert(MySqlParser::IsExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IsExpressionContext>(x, false, rb_cIsExpressionContext);
    }
  };

  template <>
  class To_Ruby<IsExpressionContextProxy*> {
  public:
    VALUE convert(IsExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IsExpressionContextProxy>(x, false, rb_cIsExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NotExpressionContext*> {
  public:
    VALUE convert(MySqlParser::NotExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NotExpressionContext>(x, false, rb_cNotExpressionContext);
    }
  };

  template <>
  class To_Ruby<NotExpressionContextProxy*> {
  public:
    VALUE convert(NotExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NotExpressionContextProxy>(x, false, rb_cNotExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LogicalExpressionContext*> {
  public:
    VALUE convert(MySqlParser::LogicalExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LogicalExpressionContext>(x, false, rb_cLogicalExpressionContext);
    }
  };

  template <>
  class To_Ruby<LogicalExpressionContextProxy*> {
  public:
    VALUE convert(LogicalExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LogicalExpressionContextProxy>(x, false, rb_cLogicalExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LogicalOperatorContext*> {
  public:
    VALUE convert(MySqlParser::LogicalOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LogicalOperatorContext>(x, false, rb_cLogicalOperatorContext);
    }
  };

  template <>
  class To_Ruby<LogicalOperatorContextProxy*> {
  public:
    VALUE convert(LogicalOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LogicalOperatorContextProxy>(x, false, rb_cLogicalOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::PredicateExpressionContext*> {
  public:
    VALUE convert(MySqlParser::PredicateExpressionContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::PredicateExpressionContext>(x, false, rb_cPredicateExpressionContext);
    }
  };

  template <>
  class To_Ruby<PredicateExpressionContextProxy*> {
  public:
    VALUE convert(PredicateExpressionContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<PredicateExpressionContextProxy>(x, false, rb_cPredicateExpressionContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SoundsLikePredicateContext*> {
  public:
    VALUE convert(MySqlParser::SoundsLikePredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SoundsLikePredicateContext>(x, false, rb_cSoundsLikePredicateContext);
    }
  };

  template <>
  class To_Ruby<SoundsLikePredicateContextProxy*> {
  public:
    VALUE convert(SoundsLikePredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SoundsLikePredicateContextProxy>(x, false, rb_cSoundsLikePredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionAtomContext>(x, false, rb_cExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<ExpressionAtomContextProxy*> {
  public:
    VALUE convert(ExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionAtomContextProxy>(x, false, rb_cExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExpressionAtomPredicateContext*> {
  public:
    VALUE convert(MySqlParser::ExpressionAtomPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExpressionAtomPredicateContext>(x, false, rb_cExpressionAtomPredicateContext);
    }
  };

  template <>
  class To_Ruby<ExpressionAtomPredicateContextProxy*> {
  public:
    VALUE convert(ExpressionAtomPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExpressionAtomPredicateContextProxy>(x, false, rb_cExpressionAtomPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubqueryComparisonPredicateContext*> {
  public:
    VALUE convert(MySqlParser::SubqueryComparisonPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubqueryComparisonPredicateContext>(x, false, rb_cSubqueryComparisonPredicateContext);
    }
  };

  template <>
  class To_Ruby<SubqueryComparisonPredicateContextProxy*> {
  public:
    VALUE convert(SubqueryComparisonPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubqueryComparisonPredicateContextProxy>(x, false, rb_cSubqueryComparisonPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonMemberOfPredicateContext*> {
  public:
    VALUE convert(MySqlParser::JsonMemberOfPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonMemberOfPredicateContext>(x, false, rb_cJsonMemberOfPredicateContext);
    }
  };

  template <>
  class To_Ruby<JsonMemberOfPredicateContextProxy*> {
  public:
    VALUE convert(JsonMemberOfPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonMemberOfPredicateContextProxy>(x, false, rb_cJsonMemberOfPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BinaryComparisonPredicateContext*> {
  public:
    VALUE convert(MySqlParser::BinaryComparisonPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BinaryComparisonPredicateContext>(x, false, rb_cBinaryComparisonPredicateContext);
    }
  };

  template <>
  class To_Ruby<BinaryComparisonPredicateContextProxy*> {
  public:
    VALUE convert(BinaryComparisonPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BinaryComparisonPredicateContextProxy>(x, false, rb_cBinaryComparisonPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::InPredicateContext*> {
  public:
    VALUE convert(MySqlParser::InPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::InPredicateContext>(x, false, rb_cInPredicateContext);
    }
  };

  template <>
  class To_Ruby<InPredicateContextProxy*> {
  public:
    VALUE convert(InPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<InPredicateContextProxy>(x, false, rb_cInPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BetweenPredicateContext*> {
  public:
    VALUE convert(MySqlParser::BetweenPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BetweenPredicateContext>(x, false, rb_cBetweenPredicateContext);
    }
  };

  template <>
  class To_Ruby<BetweenPredicateContextProxy*> {
  public:
    VALUE convert(BetweenPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BetweenPredicateContextProxy>(x, false, rb_cBetweenPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IsNullPredicateContext*> {
  public:
    VALUE convert(MySqlParser::IsNullPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IsNullPredicateContext>(x, false, rb_cIsNullPredicateContext);
    }
  };

  template <>
  class To_Ruby<IsNullPredicateContextProxy*> {
  public:
    VALUE convert(IsNullPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IsNullPredicateContextProxy>(x, false, rb_cIsNullPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::LikePredicateContext*> {
  public:
    VALUE convert(MySqlParser::LikePredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::LikePredicateContext>(x, false, rb_cLikePredicateContext);
    }
  };

  template <>
  class To_Ruby<LikePredicateContextProxy*> {
  public:
    VALUE convert(LikePredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<LikePredicateContextProxy>(x, false, rb_cLikePredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::RegexpPredicateContext*> {
  public:
    VALUE convert(MySqlParser::RegexpPredicateContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::RegexpPredicateContext>(x, false, rb_cRegexpPredicateContext);
    }
  };

  template <>
  class To_Ruby<RegexpPredicateContextProxy*> {
  public:
    VALUE convert(RegexpPredicateContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<RegexpPredicateContextProxy>(x, false, rb_cRegexpPredicateContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::UnaryExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::UnaryExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::UnaryExpressionAtomContext>(x, false, rb_cUnaryExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<UnaryExpressionAtomContextProxy*> {
  public:
    VALUE convert(UnaryExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<UnaryExpressionAtomContextProxy>(x, false, rb_cUnaryExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::CollateExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::CollateExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::CollateExpressionAtomContext>(x, false, rb_cCollateExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<CollateExpressionAtomContextProxy*> {
  public:
    VALUE convert(CollateExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<CollateExpressionAtomContextProxy>(x, false, rb_cCollateExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::VariableAssignExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::VariableAssignExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::VariableAssignExpressionAtomContext>(x, false, rb_cVariableAssignExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<VariableAssignExpressionAtomContextProxy*> {
  public:
    VALUE convert(VariableAssignExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<VariableAssignExpressionAtomContextProxy>(x, false, rb_cVariableAssignExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MysqlVariableExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::MysqlVariableExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MysqlVariableExpressionAtomContext>(x, false, rb_cMysqlVariableExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<MysqlVariableExpressionAtomContextProxy*> {
  public:
    VALUE convert(MysqlVariableExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MysqlVariableExpressionAtomContextProxy>(x, false, rb_cMysqlVariableExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NestedExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::NestedExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NestedExpressionAtomContext>(x, false, rb_cNestedExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<NestedExpressionAtomContextProxy*> {
  public:
    VALUE convert(NestedExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NestedExpressionAtomContextProxy>(x, false, rb_cNestedExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::NestedRowExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::NestedRowExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::NestedRowExpressionAtomContext>(x, false, rb_cNestedRowExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<NestedRowExpressionAtomContextProxy*> {
  public:
    VALUE convert(NestedRowExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<NestedRowExpressionAtomContextProxy>(x, false, rb_cNestedRowExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MultOperatorContext*> {
  public:
    VALUE convert(MySqlParser::MultOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MultOperatorContext>(x, false, rb_cMultOperatorContext);
    }
  };

  template <>
  class To_Ruby<MultOperatorContextProxy*> {
  public:
    VALUE convert(MultOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MultOperatorContextProxy>(x, false, rb_cMultOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::MathExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::MathExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::MathExpressionAtomContext>(x, false, rb_cMathExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<MathExpressionAtomContextProxy*> {
  public:
    VALUE convert(MathExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<MathExpressionAtomContextProxy>(x, false, rb_cMathExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::AddOperatorContext*> {
  public:
    VALUE convert(MySqlParser::AddOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::AddOperatorContext>(x, false, rb_cAddOperatorContext);
    }
  };

  template <>
  class To_Ruby<AddOperatorContextProxy*> {
  public:
    VALUE convert(AddOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<AddOperatorContextProxy>(x, false, rb_cAddOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ExistsExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::ExistsExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ExistsExpressionAtomContext>(x, false, rb_cExistsExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<ExistsExpressionAtomContextProxy*> {
  public:
    VALUE convert(ExistsExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ExistsExpressionAtomContextProxy>(x, false, rb_cExistsExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::IntervalExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::IntervalExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::IntervalExpressionAtomContext>(x, false, rb_cIntervalExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<IntervalExpressionAtomContextProxy*> {
  public:
    VALUE convert(IntervalExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<IntervalExpressionAtomContextProxy>(x, false, rb_cIntervalExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonOperatorContext*> {
  public:
    VALUE convert(MySqlParser::JsonOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonOperatorContext>(x, false, rb_cJsonOperatorContext);
    }
  };

  template <>
  class To_Ruby<JsonOperatorContextProxy*> {
  public:
    VALUE convert(JsonOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonOperatorContextProxy>(x, false, rb_cJsonOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::JsonExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::JsonExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::JsonExpressionAtomContext>(x, false, rb_cJsonExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<JsonExpressionAtomContextProxy*> {
  public:
    VALUE convert(JsonExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<JsonExpressionAtomContextProxy>(x, false, rb_cJsonExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::SubqueryExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::SubqueryExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::SubqueryExpressionAtomContext>(x, false, rb_cSubqueryExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<SubqueryExpressionAtomContextProxy*> {
  public:
    VALUE convert(SubqueryExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<SubqueryExpressionAtomContextProxy>(x, false, rb_cSubqueryExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::ConstantExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::ConstantExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::ConstantExpressionAtomContext>(x, false, rb_cConstantExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<ConstantExpressionAtomContextProxy*> {
  public:
    VALUE convert(ConstantExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<ConstantExpressionAtomContextProxy>(x, false, rb_cConstantExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FunctionCallExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::FunctionCallExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FunctionCallExpressionAtomContext>(x, false, rb_cFunctionCallExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<FunctionCallExpressionAtomContextProxy*> {
  public:
    VALUE convert(FunctionCallExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FunctionCallExpressionAtomContextProxy>(x, false, rb_cFunctionCallExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BinaryExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::BinaryExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BinaryExpressionAtomContext>(x, false, rb_cBinaryExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<BinaryExpressionAtomContextProxy*> {
  public:
    VALUE convert(BinaryExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BinaryExpressionAtomContextProxy>(x, false, rb_cBinaryExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::FullColumnNameExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::FullColumnNameExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::FullColumnNameExpressionAtomContext>(x, false, rb_cFullColumnNameExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<FullColumnNameExpressionAtomContextProxy*> {
  public:
    VALUE convert(FullColumnNameExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<FullColumnNameExpressionAtomContextProxy>(x, false, rb_cFullColumnNameExpressionAtomContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BitOperatorContext*> {
  public:
    VALUE convert(MySqlParser::BitOperatorContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BitOperatorContext>(x, false, rb_cBitOperatorContext);
    }
  };

  template <>
  class To_Ruby<BitOperatorContextProxy*> {
  public:
    VALUE convert(BitOperatorContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BitOperatorContextProxy>(x, false, rb_cBitOperatorContext);
    }
  };
}

namespace Rice::detail {
  template <>
  class To_Ruby<MySqlParser::BitExpressionAtomContext*> {
  public:
    VALUE convert(MySqlParser::BitExpressionAtomContext* const &x) {
      if (!x) return Nil;
      return Data_Object<MySqlParser::BitExpressionAtomContext>(x, false, rb_cBitExpressionAtomContext);
    }
  };

  template <>
  class To_Ruby<BitExpressionAtomContextProxy*> {
  public:
    VALUE convert(BitExpressionAtomContextProxy* const &x) {
      if (!x) return Nil;
      return Data_Object<BitExpressionAtomContextProxy>(x, false, rb_cBitExpressionAtomContext);
    }
  };
}


Object RootContextProxy::sqlStatements() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::RootContext*)orig) -> sqlStatements();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object RootContextProxy::EOF() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RootContext*)orig) -> EOF();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RootContextProxy::MINUS() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::RootContext*)orig) -> MINUS();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object RootContextProxy::MINUSAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RootContext*)orig) -> MINUS(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SqlStatementsContextProxy::sqlStatement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::SqlStatementsContext*)orig) -> sqlStatement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(sqlStatementAt(i));
    }
  }

  return std::move(a);
}

Object SqlStatementsContextProxy::sqlStatementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementsContext*)orig) -> sqlStatement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementsContextProxy::emptyStatement_() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::SqlStatementsContext*)orig) -> emptyStatement_().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(emptyStatement_At(i));
    }
  }

  return std::move(a);
}

Object SqlStatementsContextProxy::emptyStatement_At(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementsContext*)orig) -> emptyStatement_(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementsContextProxy::SEMI() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::SqlStatementsContext*)orig) -> SEMI();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object SqlStatementsContextProxy::SEMIAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SqlStatementsContext*)orig) -> SEMI(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SqlStatementsContextProxy::MINUS() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::SqlStatementsContext*)orig) -> MINUS();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object SqlStatementsContextProxy::MINUSAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SqlStatementsContext*)orig) -> MINUS(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SqlStatementContextProxy::ddlStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> ddlStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::dmlStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> dmlStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::transactionStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> transactionStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::replicationStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> replicationStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::preparedStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> preparedStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::administrationStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> administrationStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SqlStatementContextProxy::utilityStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SqlStatementContext*)orig) -> utilityStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object EmptyStatement_ContextProxy::SEMI() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::EmptyStatement_Context*)orig) -> SEMI();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DdlStatementContextProxy::createDatabase() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createDatabase();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createEvent() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createEvent();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createIndex() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createIndex();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createLogfileGroup() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createLogfileGroup();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createProcedure() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createProcedure();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createFunction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createFunction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createServer() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createServer();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createTablespaceInnodb() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createTablespaceInnodb();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createTablespaceNdb() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createTablespaceNdb();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createTrigger() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createTrigger();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createView() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createView();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::createRole() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> createRole();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterDatabase() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterDatabase();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterEvent() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterEvent();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterFunction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterFunction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterInstance() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterInstance();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterLogfileGroup() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterLogfileGroup();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterProcedure() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterProcedure();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterServer() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterServer();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterTablespace() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterTablespace();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::alterView() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> alterView();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropDatabase() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropDatabase();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropEvent() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropEvent();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropIndex() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropIndex();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropLogfileGroup() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropLogfileGroup();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropProcedure() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropProcedure();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropFunction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropFunction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropServer() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropServer();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropTablespace() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropTablespace();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropTrigger() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropTrigger();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropView() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropView();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::dropRole() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> dropRole();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::setRole() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> setRole();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::renameTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> renameTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DdlStatementContextProxy::truncateTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DdlStatementContext*)orig) -> truncateTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::selectStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> selectStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::insertStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> insertStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::updateStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> updateStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::deleteStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> deleteStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::replaceStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> replaceStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::callStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> callStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::loadDataStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> loadDataStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::loadXmlStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> loadXmlStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::doStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> doStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::handlerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> handlerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::valuesStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> valuesStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::withStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> withStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DmlStatementContextProxy::tableStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DmlStatementContext*)orig) -> tableStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::startTransaction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> startTransaction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::beginWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> beginWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::commitWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> commitWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::rollbackWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> rollbackWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::savepointStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> savepointStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::rollbackStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> rollbackStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::releaseStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> releaseStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::lockTables() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> lockTables();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TransactionStatementContextProxy::unlockTables() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TransactionStatementContext*)orig) -> unlockTables();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::changeMaster() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> changeMaster();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::changeReplicationFilter() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> changeReplicationFilter();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::purgeBinaryLogs() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> purgeBinaryLogs();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::resetMaster() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> resetMaster();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::resetSlave() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> resetSlave();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::startSlave() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> startSlave();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::stopSlave() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> stopSlave();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::startGroupReplication() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> startGroupReplication();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::stopGroupReplication() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> stopGroupReplication();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaStartTransaction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaStartTransaction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaEndTransaction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaEndTransaction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaPrepareStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaPrepareStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaCommitWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaCommitWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaRollbackWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaRollbackWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplicationStatementContextProxy::xaRecoverWork() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplicationStatementContext*)orig) -> xaRecoverWork();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object PreparedStatementContextProxy::prepareStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::PreparedStatementContext*)orig) -> prepareStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object PreparedStatementContextProxy::executeStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::PreparedStatementContext*)orig) -> executeStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object PreparedStatementContextProxy::deallocatePrepare() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::PreparedStatementContext*)orig) -> deallocatePrepare();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::alterUser() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> alterUser();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::createUser() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> createUser();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::dropUser() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> dropUser();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::grantStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> grantStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::grantProxy() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> grantProxy();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::renameUser() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> renameUser();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::revokeStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> revokeStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::revokeProxy() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> revokeProxy();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::analyzeTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> analyzeTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::checkTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> checkTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::checksumTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> checksumTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::optimizeTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> optimizeTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::repairTable() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> repairTable();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::createUdfunction() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> createUdfunction();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::installPlugin() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> installPlugin();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::uninstallPlugin() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> uninstallPlugin();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::setStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> setStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::showStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> showStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::binlogStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> binlogStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::cacheIndexStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> cacheIndexStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::flushStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> flushStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::killStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> killStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::loadIndexIntoCache() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> loadIndexIntoCache();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::resetStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> resetStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AdministrationStatementContextProxy::shutdownStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AdministrationStatementContext*)orig) -> shutdownStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::simpleDescribeStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> simpleDescribeStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::fullDescribeStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> fullDescribeStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::helpStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> helpStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::useStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> useStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::signalStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> signalStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::resignalStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> resignalStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UtilityStatementContextProxy::diagnosticsStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UtilityStatementContext*)orig) -> diagnosticsStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateDatabaseContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateDatabaseContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateDatabaseContextProxy::ifNotExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateDatabaseContext*)orig) -> ifNotExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateDatabaseContextProxy::createDatabaseOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateDatabaseContext*)orig) -> createDatabaseOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(createDatabaseOptionAt(i));
    }
  }

  return std::move(a);
}

Object CreateDatabaseContextProxy::createDatabaseOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateDatabaseContext*)orig) -> createDatabaseOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateDatabaseContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateDatabaseContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateDatabaseContextProxy::DATABASE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateDatabaseContext*)orig) -> DATABASE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateDatabaseContextProxy::SCHEMA() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateDatabaseContext*)orig) -> SCHEMA();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::scheduleExpression() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> scheduleExpression();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::routineBody() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> routineBody();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::ifNotExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> ifNotExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::enableType() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateEventContext*)orig) -> enableType();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateEventContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::EVENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> EVENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::ON() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateEventContext*)orig) -> ON();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateEventContextProxy::ONAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> ON(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::SCHEDULE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> SCHEDULE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::DO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> DO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::COMPLETION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> COMPLETION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::PRESERVE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> PRESERVE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::COMMENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> COMMENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateEventContextProxy::NOT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateEventContext*)orig) -> NOT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateIndexContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateIndexContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateIndexContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateIndexContextProxy::indexColumnNames() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateIndexContext*)orig) -> indexColumnNames();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateIndexContextProxy::indexType() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateIndexContext*)orig) -> indexType();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateIndexContextProxy::indexOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateIndexContext*)orig) -> indexOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(indexOptionAt(i));
    }
  }

  return std::move(a);
}

Object CreateIndexContextProxy::indexOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateIndexContext*)orig) -> indexOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateIndexContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::INDEX() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> INDEX();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::ON() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> ON();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::ALGORITHM() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> ALGORITHM();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::ALGORITHMAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> ALGORITHM(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::LOCK() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> LOCK();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::LOCKAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> LOCK(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::ONLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> ONLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::OFFLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> OFFLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::UNIQUE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> UNIQUE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::FULLTEXT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> FULLTEXT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::SPATIAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> SPATIAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::DEFAULT() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> DEFAULT();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::DEFAULTAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> DEFAULT(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::INPLACE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> INPLACE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::INPLACEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> INPLACE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::COPY() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> COPY();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::COPYAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> COPY(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::NONE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> NONE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::NONEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> NONE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::SHARED() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> SHARED();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::SHAREDAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> SHARED(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::EXCLUSIVE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> EXCLUSIVE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::EXCLUSIVEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> EXCLUSIVE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateIndexContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateIndexContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateIndexContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateIndexContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::uid() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateLogfileGroupContext*)orig) -> uid().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(uidAt(i));
    }
  }

  return std::move(a);
}

Object CreateLogfileGroupContextProxy::uidAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateLogfileGroupContext*)orig) -> uid(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateLogfileGroupContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateLogfileGroupContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateLogfileGroupContextProxy::fileSizeLiteral() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateLogfileGroupContext*)orig) -> fileSizeLiteral().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(fileSizeLiteralAt(i));
    }
  }

  return std::move(a);
}

Object CreateLogfileGroupContextProxy::fileSizeLiteralAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateLogfileGroupContext*)orig) -> fileSizeLiteral(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateLogfileGroupContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::LOGFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> LOGFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::GROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> GROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::ADD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> ADD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::UNDOFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> UNDOFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::STRING_LITERAL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateLogfileGroupContext*)orig) -> STRING_LITERAL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateLogfileGroupContextProxy::STRING_LITERALAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> STRING_LITERAL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::INITIAL_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> INITIAL_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::UNDO_BUFFER_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> UNDO_BUFFER_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::REDO_BUFFER_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> REDO_BUFFER_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::NODEGROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> NODEGROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::WAIT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> WAIT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::COMMENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> COMMENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateLogfileGroupContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateLogfileGroupContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateLogfileGroupContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateLogfileGroupContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateProcedureContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateProcedureContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateProcedureContextProxy::routineBody() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateProcedureContext*)orig) -> routineBody();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateProcedureContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateProcedureContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateProcedureContextProxy::procedureParameter() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateProcedureContext*)orig) -> procedureParameter().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(procedureParameterAt(i));
    }
  }

  return std::move(a);
}

Object CreateProcedureContextProxy::procedureParameterAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateProcedureContext*)orig) -> procedureParameter(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateProcedureContextProxy::routineOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateProcedureContext*)orig) -> routineOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(routineOptionAt(i));
    }
  }

  return std::move(a);
}

Object CreateProcedureContextProxy::routineOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateProcedureContext*)orig) -> routineOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateProcedureContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateProcedureContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateProcedureContextProxy::PROCEDURE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateProcedureContext*)orig) -> PROCEDURE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateProcedureContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateProcedureContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateProcedureContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateProcedureContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateProcedureContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateProcedureContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateProcedureContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateProcedureContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::dataType() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> dataType();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::routineBody() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> routineBody();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::returnStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> returnStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::ifNotExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> ifNotExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::functionParameter() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateFunctionContext*)orig) -> functionParameter().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(functionParameterAt(i));
    }
  }

  return std::move(a);
}

Object CreateFunctionContextProxy::functionParameterAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> functionParameter(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::routineOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateFunctionContext*)orig) -> routineOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(routineOptionAt(i));
    }
  }

  return std::move(a);
}

Object CreateFunctionContextProxy::routineOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateFunctionContext*)orig) -> routineOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateFunctionContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::FUNCTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> FUNCTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::RETURNS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> RETURNS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::AGGREGATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> AGGREGATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateFunctionContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateFunctionContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateFunctionContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateFunctionContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateServerContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateServerContextProxy::serverOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateServerContext*)orig) -> serverOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(serverOptionAt(i));
    }
  }

  return std::move(a);
}

Object CreateServerContextProxy::serverOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateServerContext*)orig) -> serverOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateServerContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::SERVER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> SERVER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::FOREIGN() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> FOREIGN();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::DATA() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> DATA();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::WRAPPER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> WRAPPER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::OPTIONS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> OPTIONS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::MYSQL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> MYSQL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateServerContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateServerContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateServerContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateServerContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceInnodbContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceInnodbContextProxy::fileSizeLiteral() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> fileSizeLiteral();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceInnodbContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::TABLESPACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> TABLESPACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::ADD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> ADD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::DATAFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> DATAFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::FILE_BLOCK_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> FILE_BLOCK_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateTablespaceInnodbContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceInnodbContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceInnodbContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::uid() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> uid().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(uidAt(i));
    }
  }

  return std::move(a);
}

Object CreateTablespaceNdbContextProxy::uidAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> uid(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceNdbContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceNdbContextProxy::fileSizeLiteral() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> fileSizeLiteral().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(fileSizeLiteralAt(i));
    }
  }

  return std::move(a);
}

Object CreateTablespaceNdbContextProxy::fileSizeLiteralAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> fileSizeLiteral(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTablespaceNdbContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::TABLESPACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> TABLESPACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::ADD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> ADD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::DATAFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> DATAFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::USE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> USE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::LOGFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> LOGFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::GROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> GROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::STRING_LITERAL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> STRING_LITERAL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateTablespaceNdbContextProxy::STRING_LITERALAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> STRING_LITERAL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::EXTENT_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> EXTENT_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::INITIAL_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> INITIAL_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::AUTOEXTEND_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> AUTOEXTEND_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::MAX_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> MAX_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::NODEGROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> NODEGROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::WAIT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> WAIT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::COMMENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> COMMENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTablespaceNdbContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateTablespaceNdbContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTablespaceNdbContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTriggerContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTriggerContextProxy::routineBody() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTriggerContext*)orig) -> routineBody();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTriggerContextProxy::fullId() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateTriggerContext*)orig) -> fullId().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(fullIdAt(i));
    }
  }

  return std::move(a);
}

Object CreateTriggerContextProxy::fullIdAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTriggerContext*)orig) -> fullId(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTriggerContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateTriggerContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateTriggerContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::TRIGGER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> TRIGGER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::ON() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> ON();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::FOR() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> FOR();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::EACH() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> EACH();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::ROW() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> ROW();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::BEFORE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> BEFORE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::AFTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> AFTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::INSERT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> INSERT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::UPDATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> UPDATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::DELETE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> DELETE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::FOLLOWS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> FOLLOWS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateTriggerContextProxy::PRECEDES() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateTriggerContext*)orig) -> PRECEDES();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::selectStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> selectStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::orReplace() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> orReplace();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::uidList() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> uidList();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::withClause() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateViewContext*)orig) -> withClause();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateViewContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::VIEW() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> VIEW();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::AS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> AS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::LR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateViewContext*)orig) -> LR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateViewContextProxy::LR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> LR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::RR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateViewContext*)orig) -> RR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateViewContextProxy::RR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> RR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::ALGORITHM() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> ALGORITHM();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::EQUAL_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> EQUAL_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::SQL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> SQL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::SECURITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> SECURITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::UNDEFINED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> UNDEFINED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::MERGE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> MERGE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::TEMPTABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> TEMPTABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::DEFINER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> DEFINER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::INVOKER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> INVOKER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::WITH() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> WITH();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::CHECK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> CHECK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::OPTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> OPTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::CASCADED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> CASCADED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateViewContextProxy::LOCAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateViewContext*)orig) -> LOCAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateRoleContextProxy::roleName() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::CreateRoleContext*)orig) -> roleName().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(roleNameAt(i));
    }
  }

  return std::move(a);
}

Object CreateRoleContextProxy::roleNameAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateRoleContext*)orig) -> roleName(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateRoleContextProxy::ifNotExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CreateRoleContext*)orig) -> ifNotExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CreateRoleContextProxy::CREATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateRoleContext*)orig) -> CREATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateRoleContextProxy::ROLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateRoleContext*)orig) -> ROLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CreateRoleContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CreateRoleContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CreateRoleContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CreateRoleContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::fullId() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::AlterEventContext*)orig) -> fullId().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(fullIdAt(i));
    }
  }

  return std::move(a);
}

Object AlterEventContextProxy::fullIdAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterEventContext*)orig) -> fullId(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterEventContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterEventContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterEventContextProxy::scheduleExpression() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterEventContext*)orig) -> scheduleExpression();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterEventContextProxy::enableType() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterEventContext*)orig) -> enableType();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterEventContextProxy::routineBody() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterEventContext*)orig) -> routineBody();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterEventContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::EVENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> EVENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::ON() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::AlterEventContext*)orig) -> ON();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object AlterEventContextProxy::ONAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> ON(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::SCHEDULE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> SCHEDULE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::COMPLETION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> COMPLETION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::PRESERVE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> PRESERVE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::RENAME() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> RENAME();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::TO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> TO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::COMMENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> COMMENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::DO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> DO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterEventContextProxy::NOT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterEventContext*)orig) -> NOT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterFunctionContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterFunctionContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterFunctionContextProxy::routineOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::AlterFunctionContext*)orig) -> routineOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(routineOptionAt(i));
    }
  }

  return std::move(a);
}

Object AlterFunctionContextProxy::routineOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterFunctionContext*)orig) -> routineOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterFunctionContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterFunctionContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterFunctionContextProxy::FUNCTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterFunctionContext*)orig) -> FUNCTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::INSTANCE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> INSTANCE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::ROTATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> ROTATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::INNODB() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> INNODB();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::MASTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> MASTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterInstanceContextProxy::KEY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterInstanceContext*)orig) -> KEY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterLogfileGroupContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterLogfileGroupContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterLogfileGroupContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterLogfileGroupContextProxy::fileSizeLiteral() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterLogfileGroupContext*)orig) -> fileSizeLiteral();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterLogfileGroupContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::LOGFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> LOGFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::GROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> GROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::ADD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> ADD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::UNDOFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> UNDOFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::INITIAL_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> INITIAL_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::WAIT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> WAIT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterLogfileGroupContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::AlterLogfileGroupContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object AlterLogfileGroupContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterLogfileGroupContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterProcedureContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterProcedureContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterProcedureContextProxy::routineOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::AlterProcedureContext*)orig) -> routineOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(routineOptionAt(i));
    }
  }

  return std::move(a);
}

Object AlterProcedureContextProxy::routineOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterProcedureContext*)orig) -> routineOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterProcedureContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterProcedureContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterProcedureContextProxy::PROCEDURE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterProcedureContext*)orig) -> PROCEDURE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterServerContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterServerContextProxy::serverOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::AlterServerContext*)orig) -> serverOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(serverOptionAt(i));
    }
  }

  return std::move(a);
}

Object AlterServerContextProxy::serverOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterServerContext*)orig) -> serverOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterServerContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::SERVER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> SERVER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::OPTIONS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> OPTIONS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterServerContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::AlterServerContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object AlterServerContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterServerContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTableContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTableContextProxy::waitNowaitClause() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTableContext*)orig) -> waitNowaitClause();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTableContextProxy::alterSpecification() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::AlterTableContext*)orig) -> alterSpecification().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(alterSpecificationAt(i));
    }
  }

  return std::move(a);
}

Object AlterTableContextProxy::alterSpecificationAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTableContext*)orig) -> alterSpecification(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTableContextProxy::partitionDefinitions() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTableContext*)orig) -> partitionDefinitions();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTableContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::IGNORE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> IGNORE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::ONLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> ONLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::OFFLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> OFFLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTableContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::AlterTableContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object AlterTableContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTableContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTablespaceContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTablespaceContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTablespaceContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTablespaceContextProxy::fileSizeLiteral() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterTablespaceContext*)orig) -> fileSizeLiteral();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterTablespaceContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::TABLESPACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> TABLESPACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::DATAFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> DATAFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::ADD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> ADD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::INITIAL_SIZE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> INITIAL_SIZE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::AlterTablespaceContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object AlterTablespaceContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterTablespaceContextProxy::WAIT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterTablespaceContext*)orig) -> WAIT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterViewContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterViewContextProxy::selectStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterViewContext*)orig) -> selectStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterViewContextProxy::ownerStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterViewContext*)orig) -> ownerStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterViewContextProxy::uidList() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::AlterViewContext*)orig) -> uidList();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object AlterViewContextProxy::ALTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> ALTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::VIEW() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> VIEW();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::AS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> AS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::ALGORITHM() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> ALGORITHM();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::EQUAL_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> EQUAL_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::SQL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> SQL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::SECURITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> SECURITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::WITH() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> WITH();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::CHECK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> CHECK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::OPTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> OPTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::UNDEFINED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> UNDEFINED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::MERGE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> MERGE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::TEMPTABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> TEMPTABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::DEFINER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> DEFINER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::INVOKER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> INVOKER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::CASCADED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> CASCADED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object AlterViewContextProxy::LOCAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::AlterViewContext*)orig) -> LOCAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropDatabaseContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropDatabaseContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropDatabaseContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropDatabaseContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropDatabaseContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropDatabaseContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropDatabaseContextProxy::DATABASE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropDatabaseContext*)orig) -> DATABASE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropDatabaseContextProxy::SCHEMA() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropDatabaseContext*)orig) -> SCHEMA();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropEventContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropEventContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropEventContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropEventContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropEventContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropEventContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropEventContextProxy::EVENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropEventContext*)orig) -> EVENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropIndexContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropIndexContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropIndexContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropIndexContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::INDEX() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> INDEX();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::ON() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> ON();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::ALGORITHM() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> ALGORITHM();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::ALGORITHMAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> ALGORITHM(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::LOCK() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> LOCK();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::LOCKAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> LOCK(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::ONLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> ONLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::OFFLINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> OFFLINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::DEFAULT() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> DEFAULT();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::DEFAULTAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> DEFAULT(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::INPLACE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> INPLACE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::INPLACEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> INPLACE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::COPY() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> COPY();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::COPYAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> COPY(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::NONE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> NONE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::NONEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> NONE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::SHARED() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> SHARED();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::SHAREDAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> SHARED(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::EXCLUSIVE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> EXCLUSIVE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::EXCLUSIVEAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> EXCLUSIVE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropIndexContextProxy::EQUAL_SYMBOL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropIndexContext*)orig) -> EQUAL_SYMBOL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropIndexContextProxy::EQUAL_SYMBOLAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropIndexContext*)orig) -> EQUAL_SYMBOL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropLogfileGroupContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropLogfileGroupContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropLogfileGroupContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropLogfileGroupContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropLogfileGroupContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropLogfileGroupContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropLogfileGroupContextProxy::LOGFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropLogfileGroupContext*)orig) -> LOGFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropLogfileGroupContextProxy::GROUP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropLogfileGroupContext*)orig) -> GROUP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropLogfileGroupContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropLogfileGroupContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropLogfileGroupContextProxy::EQUAL_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropLogfileGroupContext*)orig) -> EQUAL_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropProcedureContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropProcedureContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropProcedureContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropProcedureContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropProcedureContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropProcedureContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropProcedureContextProxy::PROCEDURE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropProcedureContext*)orig) -> PROCEDURE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropFunctionContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropFunctionContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropFunctionContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropFunctionContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropFunctionContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropFunctionContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropFunctionContextProxy::FUNCTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropFunctionContext*)orig) -> FUNCTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropServerContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropServerContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropServerContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropServerContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropServerContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropServerContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropServerContextProxy::SERVER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropServerContext*)orig) -> SERVER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTableContextProxy::tables() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTableContext*)orig) -> tables();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTableContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTableContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTableContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTableContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTableContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTableContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTableContextProxy::TEMPORARY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTableContext*)orig) -> TEMPORARY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTableContextProxy::RESTRICT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTableContext*)orig) -> RESTRICT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTableContextProxy::CASCADE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTableContext*)orig) -> CASCADE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTablespaceContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTablespaceContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTablespaceContextProxy::engineName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTablespaceContext*)orig) -> engineName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTablespaceContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTablespaceContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTablespaceContextProxy::TABLESPACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTablespaceContext*)orig) -> TABLESPACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTablespaceContextProxy::ENGINE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTablespaceContext*)orig) -> ENGINE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTablespaceContextProxy::EQUAL_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTablespaceContext*)orig) -> EQUAL_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTriggerContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTriggerContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTriggerContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropTriggerContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropTriggerContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTriggerContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropTriggerContextProxy::TRIGGER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropTriggerContext*)orig) -> TRIGGER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropViewContextProxy::fullId() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::DropViewContext*)orig) -> fullId().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(fullIdAt(i));
    }
  }

  return std::move(a);
}

Object DropViewContextProxy::fullIdAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropViewContext*)orig) -> fullId(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropViewContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropViewContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropViewContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropViewContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropViewContextProxy::VIEW() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropViewContext*)orig) -> VIEW();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropViewContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropViewContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropViewContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropViewContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropViewContextProxy::RESTRICT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropViewContext*)orig) -> RESTRICT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropViewContextProxy::CASCADE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropViewContext*)orig) -> CASCADE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropRoleContextProxy::roleName() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::DropRoleContext*)orig) -> roleName().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(roleNameAt(i));
    }
  }

  return std::move(a);
}

Object DropRoleContextProxy::roleNameAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropRoleContext*)orig) -> roleName(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropRoleContextProxy::ifExists() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DropRoleContext*)orig) -> ifExists();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DropRoleContextProxy::DROP() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropRoleContext*)orig) -> DROP();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropRoleContextProxy::ROLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropRoleContext*)orig) -> ROLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DropRoleContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::DropRoleContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object DropRoleContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DropRoleContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::roleName() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::SetRoleContext*)orig) -> roleName().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(roleNameAt(i));
    }
  }

  return std::move(a);
}

Object SetRoleContextProxy::roleNameAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SetRoleContext*)orig) -> roleName(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SetRoleContextProxy::userName() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::SetRoleContext*)orig) -> userName().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(userNameAt(i));
    }
  }

  return std::move(a);
}

Object SetRoleContextProxy::userNameAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SetRoleContext*)orig) -> userName(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SetRoleContextProxy::uid() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::SetRoleContext*)orig) -> uid().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(uidAt(i));
    }
  }

  return std::move(a);
}

Object SetRoleContextProxy::uidAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SetRoleContext*)orig) -> uid(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SetRoleContextProxy::roleOption() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SetRoleContext*)orig) -> roleOption();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SetRoleContextProxy::SET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> SET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::DEFAULT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> DEFAULT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::ROLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> ROLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::TO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> TO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::NONE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> NONE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::ALL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> ALL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SetRoleContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::SetRoleContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object SetRoleContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SetRoleContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RenameTableContextProxy::renameTableClause() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::RenameTableContext*)orig) -> renameTableClause().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(renameTableClauseAt(i));
    }
  }

  return std::move(a);
}

Object RenameTableContextProxy::renameTableClauseAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::RenameTableContext*)orig) -> renameTableClause(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object RenameTableContextProxy::RENAME() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RenameTableContext*)orig) -> RENAME();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RenameTableContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RenameTableContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RenameTableContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::RenameTableContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object RenameTableContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RenameTableContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object TruncateTableContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TruncateTableContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TruncateTableContextProxy::TRUNCATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::TruncateTableContext*)orig) -> TRUNCATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object TruncateTableContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::TruncateTableContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::insertStatementValue() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> insertStatementValue();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::updatedElement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::InsertStatementContext*)orig) -> updatedElement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(updatedElementAt(i));
    }
  }

  return std::move(a);
}

Object InsertStatementContextProxy::updatedElementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> updatedElement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::uidList() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> uidList();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::fullColumnNameList() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::InsertStatementContext*)orig) -> fullColumnNameList();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object InsertStatementContextProxy::INSERT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> INSERT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::SET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> SET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::IGNORE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> IGNORE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::INTO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> INTO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::PARTITION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> PARTITION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::LR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::InsertStatementContext*)orig) -> LR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object InsertStatementContextProxy::LR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> LR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::RR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::InsertStatementContext*)orig) -> RR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object InsertStatementContextProxy::RR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> RR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::ON() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> ON();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::DUPLICATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> DUPLICATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::KEY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> KEY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::UPDATE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> UPDATE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::LOW_PRIORITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> LOW_PRIORITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::DELAYED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> DELAYED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::HIGH_PRIORITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> HIGH_PRIORITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::InsertStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object InsertStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object InsertStatementContextProxy::AS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::InsertStatementContext*)orig) -> AS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object UpdateStatementContextProxy::singleUpdateStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UpdateStatementContext*)orig) -> singleUpdateStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object UpdateStatementContextProxy::multipleUpdateStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::UpdateStatementContext*)orig) -> multipleUpdateStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DeleteStatementContextProxy::singleDeleteStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DeleteStatementContext*)orig) -> singleDeleteStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DeleteStatementContextProxy::multipleDeleteStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DeleteStatementContext*)orig) -> multipleDeleteStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplaceStatementContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplaceStatementContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplaceStatementContextProxy::insertStatementValue() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplaceStatementContext*)orig) -> insertStatementValue();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplaceStatementContextProxy::updatedElement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::ReplaceStatementContext*)orig) -> updatedElement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(updatedElementAt(i));
    }
  }

  return std::move(a);
}

Object ReplaceStatementContextProxy::updatedElementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplaceStatementContext*)orig) -> updatedElement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplaceStatementContextProxy::uidList() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::ReplaceStatementContext*)orig) -> uidList().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(uidListAt(i));
    }
  }

  return std::move(a);
}

Object ReplaceStatementContextProxy::uidListAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReplaceStatementContext*)orig) -> uidList(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReplaceStatementContextProxy::REPLACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> REPLACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::SET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> SET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::INTO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> INTO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::PARTITION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> PARTITION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::LR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ReplaceStatementContext*)orig) -> LR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ReplaceStatementContextProxy::LR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> LR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::RR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ReplaceStatementContext*)orig) -> RR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ReplaceStatementContextProxy::RR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> RR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::LOW_PRIORITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> LOW_PRIORITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::DELAYED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> DELAYED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReplaceStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ReplaceStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ReplaceStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReplaceStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CallStatementContextProxy::fullId() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CallStatementContext*)orig) -> fullId();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CallStatementContextProxy::constants() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CallStatementContext*)orig) -> constants();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CallStatementContextProxy::expressions() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::CallStatementContext*)orig) -> expressions();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object CallStatementContextProxy::CALL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CallStatementContext*)orig) -> CALL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CallStatementContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CallStatementContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CallStatementContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CallStatementContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::uidList() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> uidList();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::decimalLiteral() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> decimalLiteral();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::assignmentField() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadDataStatementContext*)orig) -> assignmentField().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(assignmentFieldAt(i));
    }
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::assignmentFieldAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> assignmentField(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::updatedElement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadDataStatementContext*)orig) -> updatedElement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(updatedElementAt(i));
    }
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::updatedElementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> updatedElement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::charsetName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> charsetName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::selectFieldsInto() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadDataStatementContext*)orig) -> selectFieldsInto().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(selectFieldsIntoAt(i));
    }
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::selectFieldsIntoAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> selectFieldsInto(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::selectLinesInto() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadDataStatementContext*)orig) -> selectLinesInto().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(selectLinesIntoAt(i));
    }
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::selectLinesIntoAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadDataStatementContext*)orig) -> selectLinesInto(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadDataStatementContextProxy::LOAD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> LOAD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::DATA() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> DATA();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::INFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> INFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::INTO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> INTO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::LOCAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> LOCAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::PARTITION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> PARTITION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::LR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> LR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::LR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> LR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::RR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> RR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::RR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> RR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::CHARACTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> CHARACTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::SET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> SET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::SETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> SET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::LINES() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> LINES();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::LINESAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> LINES(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::IGNORE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> IGNORE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::IGNOREAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> IGNORE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::LOW_PRIORITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> LOW_PRIORITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::CONCURRENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> CONCURRENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::REPLACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> REPLACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::FIELDS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> FIELDS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::COLUMNS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> COLUMNS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::ROWS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> ROWS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadDataStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadDataStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadDataStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadDataStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadXmlStatementContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadXmlStatementContextProxy::decimalLiteral() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadXmlStatementContext*)orig) -> decimalLiteral();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadXmlStatementContextProxy::assignmentField() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadXmlStatementContext*)orig) -> assignmentField().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(assignmentFieldAt(i));
    }
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::assignmentFieldAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadXmlStatementContext*)orig) -> assignmentField(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadXmlStatementContextProxy::updatedElement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LoadXmlStatementContext*)orig) -> updatedElement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(updatedElementAt(i));
    }
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::updatedElementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadXmlStatementContext*)orig) -> updatedElement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadXmlStatementContextProxy::charsetName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LoadXmlStatementContext*)orig) -> charsetName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LoadXmlStatementContextProxy::LOAD() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LOAD();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::XML() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> XML();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::INFILE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> INFILE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::INTO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> INTO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::STRING_LITERAL() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadXmlStatementContext*)orig) -> STRING_LITERAL();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::STRING_LITERALAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> STRING_LITERAL(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::LOCAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LOCAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::CHARACTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> CHARACTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::SET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadXmlStatementContext*)orig) -> SET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::SETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> SET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::ROWS() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadXmlStatementContext*)orig) -> ROWS();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::ROWSAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> ROWS(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::IDENTIFIED() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> IDENTIFIED();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::BY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> BY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::LESS_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LESS_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::GREATER_SYMBOL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> GREATER_SYMBOL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::IGNORE() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadXmlStatementContext*)orig) -> IGNORE();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::IGNOREAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> IGNORE(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::LR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::RR_BRACKET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> RR_BRACKET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::LOW_PRIORITY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LOW_PRIORITY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::CONCURRENT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> CONCURRENT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::REPLACE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> REPLACE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::LINES() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> LINES();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LoadXmlStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LoadXmlStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LoadXmlStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LoadXmlStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object DoStatementContextProxy::expressions() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::DoStatementContext*)orig) -> expressions();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object DoStatementContextProxy::DO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::DoStatementContext*)orig) -> DO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object HandlerStatementContextProxy::handlerOpenStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::HandlerStatementContext*)orig) -> handlerOpenStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object HandlerStatementContextProxy::handlerReadIndexStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::HandlerStatementContext*)orig) -> handlerReadIndexStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object HandlerStatementContextProxy::handlerReadStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::HandlerStatementContext*)orig) -> handlerReadStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object HandlerStatementContextProxy::handlerCloseStatement() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::HandlerStatementContext*)orig) -> handlerCloseStatement();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ValuesStatementContextProxy::expressionsWithDefaults() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::ValuesStatementContext*)orig) -> expressionsWithDefaults().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(expressionsWithDefaultsAt(i));
    }
  }

  return std::move(a);
}

Object ValuesStatementContextProxy::expressionsWithDefaultsAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ValuesStatementContext*)orig) -> expressionsWithDefaults(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ValuesStatementContextProxy::VALUES() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ValuesStatementContext*)orig) -> VALUES();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ValuesStatementContextProxy::LR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ValuesStatementContext*)orig) -> LR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ValuesStatementContextProxy::LR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ValuesStatementContext*)orig) -> LR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ValuesStatementContextProxy::RR_BRACKET() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ValuesStatementContext*)orig) -> RR_BRACKET();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ValuesStatementContextProxy::RR_BRACKETAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ValuesStatementContext*)orig) -> RR_BRACKET(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ValuesStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ValuesStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ValuesStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ValuesStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object WithStatementContextProxy::commonTableExpressions() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::WithStatementContext*)orig) -> commonTableExpressions().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(commonTableExpressionsAt(i));
    }
  }

  return std::move(a);
}

Object WithStatementContextProxy::commonTableExpressionsAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::WithStatementContext*)orig) -> commonTableExpressions(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object WithStatementContextProxy::WITH() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::WithStatementContext*)orig) -> WITH();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object WithStatementContextProxy::RECURSIVE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::WithStatementContext*)orig) -> RECURSIVE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object WithStatementContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::WithStatementContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object WithStatementContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::WithStatementContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object TableStatementContextProxy::tableName() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TableStatementContext*)orig) -> tableName();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TableStatementContextProxy::orderByClause() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TableStatementContext*)orig) -> orderByClause();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TableStatementContextProxy::limitClause() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::TableStatementContext*)orig) -> limitClause();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object TableStatementContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::TableStatementContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object StartTransactionContextProxy::transactionMode() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::StartTransactionContext*)orig) -> transactionMode().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(transactionModeAt(i));
    }
  }

  return std::move(a);
}

Object StartTransactionContextProxy::transactionModeAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::StartTransactionContext*)orig) -> transactionMode(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object StartTransactionContextProxy::START() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::StartTransactionContext*)orig) -> START();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object StartTransactionContextProxy::TRANSACTION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::StartTransactionContext*)orig) -> TRANSACTION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object StartTransactionContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::StartTransactionContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object StartTransactionContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::StartTransactionContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object BeginWorkContextProxy::BEGIN() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::BeginWorkContext*)orig) -> BEGIN();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object BeginWorkContextProxy::WORK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::BeginWorkContext*)orig) -> WORK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::COMMIT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> COMMIT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::WORK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> WORK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::AND() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> AND();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::CHAIN() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> CHAIN();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::RELEASE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> RELEASE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object CommitWorkContextProxy::NO() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::CommitWorkContext*)orig) -> NO();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object CommitWorkContextProxy::NOAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::CommitWorkContext*)orig) -> NO(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::ROLLBACK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> ROLLBACK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::WORK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> WORK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::AND() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> AND();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::CHAIN() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> CHAIN();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::RELEASE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> RELEASE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackWorkContextProxy::NO() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::RollbackWorkContext*)orig) -> NO();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object RollbackWorkContextProxy::NOAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackWorkContext*)orig) -> NO(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object SavepointStatementContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::SavepointStatementContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object SavepointStatementContextProxy::SAVEPOINT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::SavepointStatementContext*)orig) -> SAVEPOINT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackStatementContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::RollbackStatementContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object RollbackStatementContextProxy::ROLLBACK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackStatementContext*)orig) -> ROLLBACK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackStatementContextProxy::TO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackStatementContext*)orig) -> TO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackStatementContextProxy::WORK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackStatementContext*)orig) -> WORK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object RollbackStatementContextProxy::SAVEPOINT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::RollbackStatementContext*)orig) -> SAVEPOINT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReleaseStatementContextProxy::uid() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ReleaseStatementContext*)orig) -> uid();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ReleaseStatementContextProxy::RELEASE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReleaseStatementContext*)orig) -> RELEASE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ReleaseStatementContextProxy::SAVEPOINT() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ReleaseStatementContext*)orig) -> SAVEPOINT();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LockTablesContextProxy::lockTableElement() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::LockTablesContext*)orig) -> lockTableElement().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(lockTableElementAt(i));
    }
  }

  return std::move(a);
}

Object LockTablesContextProxy::lockTableElementAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LockTablesContext*)orig) -> lockTableElement(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LockTablesContextProxy::waitNowaitClause() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::LockTablesContext*)orig) -> waitNowaitClause();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object LockTablesContextProxy::LOCK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LockTablesContext*)orig) -> LOCK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LockTablesContextProxy::TABLE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LockTablesContext*)orig) -> TABLE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LockTablesContextProxy::TABLES() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LockTablesContext*)orig) -> TABLES();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object LockTablesContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::LockTablesContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object LockTablesContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::LockTablesContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object UnlockTablesContextProxy::UNLOCK() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::UnlockTablesContext*)orig) -> UNLOCK();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object UnlockTablesContextProxy::TABLES() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::UnlockTablesContext*)orig) -> TABLES();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeMasterContextProxy::masterOption() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::ChangeMasterContext*)orig) -> masterOption().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(masterOptionAt(i));
    }
  }

  return std::move(a);
}

Object ChangeMasterContextProxy::masterOptionAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ChangeMasterContext*)orig) -> masterOption(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ChangeMasterContextProxy::channelOption() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ChangeMasterContext*)orig) -> channelOption();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ChangeMasterContextProxy::CHANGE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeMasterContext*)orig) -> CHANGE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeMasterContextProxy::MASTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeMasterContext*)orig) -> MASTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeMasterContextProxy::TO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeMasterContext*)orig) -> TO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeMasterContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ChangeMasterContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ChangeMasterContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeMasterContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeReplicationFilterContextProxy::replicationFilter() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> replicationFilter().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(replicationFilterAt(i));
    }
  }

  return std::move(a);
}

Object ChangeReplicationFilterContextProxy::replicationFilterAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> replicationFilter(i);

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ChangeReplicationFilterContextProxy::CHANGE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> CHANGE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeReplicationFilterContextProxy::REPLICATION() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> REPLICATION();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeReplicationFilterContextProxy::FILTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> FILTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ChangeReplicationFilterContextProxy::COMMA() {
  Array a;

  if (orig == nullptr) {
    return std::move(a);
  }

  auto vec = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> COMMA();

  for (auto it = vec.begin(); it != vec.end(); it ++) {
    TerminalNodeProxy proxy(*it);
    a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
  }

  return std::move(a);
}

Object ChangeReplicationFilterContextProxy::COMMAAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ChangeReplicationFilterContext*)orig) -> COMMA(i);

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::PURGE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> PURGE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::LOGS() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> LOGS();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::BINARY() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> BINARY();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::MASTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> MASTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::TO() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> TO();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::BEFORE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> BEFORE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object PurgeBinaryLogsContextProxy::STRING_LITERAL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::PurgeBinaryLogsContext*)orig) -> STRING_LITERAL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ResetMasterContextProxy::RESET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ResetMasterContext*)orig) -> RESET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ResetMasterContextProxy::MASTER() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ResetMasterContext*)orig) -> MASTER();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ResetSlaveContextProxy::channelOption() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::ResetSlaveContext*)orig) -> channelOption();

  if (ctx == nullptr) {
    return Qnil;
  }

  for (auto child : getChildren()) {
    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
      return child;
    }
  }

  return Nil;
}

Object ResetSlaveContextProxy::RESET() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ResetSlaveContext*)orig) -> RESET();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ResetSlaveContextProxy::SLAVE() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ResetSlaveContext*)orig) -> SLAVE();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object ResetSlaveContextProxy::ALL() {
  if (orig == nullptr) {
    return Qnil;
  }

  auto token = ((MySqlParser::ResetSlaveContext*)orig) -> ALL();

  if (token == nullptr) {
    return Qnil;
  }

  TerminalNodeProxy proxy(token);
  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
}

Object StartSlaveContextProxy::threadType() {
  Array a;

  if (orig != nullptr) {
    size_t count = ((MySqlParser::StartSlaveContext*)orig) -> threadType().size();

    for (size_t i = 0; i < count; i ++) {
      a.push(threadTypeAt(i));
    }
  }

  return std::move(a);
}

Object StartSlaveContextProxy::threadTypeAt(size_t i) {
  if (orig == nullptr) {
    return Qnil;
  }

  auto ctx = ((MySqlParser::StartSlaveContext*)orig) -> threadType(i);

  if (ctx == nullptr) {