groonga 0.9.1 → 1.0.0

data/license/RUBY

@@ -1,59 +0,0 @@
-Rcairo is copyrighted free software by the persons listed in AUTHORS 
-distributed under the same conditions as ruby; which follow:
-
-Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
-You can redistribute it and/or modify it under either the terms of the GPL
-(see the file GPL), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-	  modifications to Usenet or an equivalent medium, or by allowing
-	  the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or binary form,
-     provided that you do at least ONE of the following:
-
-       a) distribute the binaries and library files of the software,
-	  together with instructions (in the manual page or equivalent)
-	  on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-	  the software.
-
-       c) give non-standard binaries non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     software (possibly commercial).  But some files in the distribution
-     are not written by the author, so that they are not under these terms.
-
-     For the list of those files and their copying conditions, see the
-     file LEGAL.
-
-  5. The scripts and library files supplied as input to or produced as 
-     output from the software do not automatically fall under the
-     copyright of the software, but belong to whomever generated them, 
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.

data/misc/grnop2ruby.rb

@@ -1,49 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009  Yuto Hayamizu <y.hayamizu@gmail.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License version 2.1 as published by the Free Software Foundation.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-#
-# This script expects "groonga.h" as a first argument, extracts the
-# 'grn_operator', and write 'rb_define_const's of 'grn_operator' to
-# standard outout.
-#
-# Usage:
-#   ruby grnop2ruby.rb /path/to/groonga.h
-#
-
-replace_dictionary = {
-  "VAR" => "VARIABLE",
-  "EXPR" => "EXPRESSION",
-  "NOP" => "NO_OPERATION",
-  "REF" => "REFERENCE",
-  "OBJ" => "OBJECT",
-  "INCR" => "INCREMENT",
-  "DECR" => "DECREMENT",
-  "MOD" => "MODULO",
-  "LCP" => "LONGEST_COMMON_PREFIX",
-}
-
-ARGF.each_line do |line|
-  case line
-  when /\A\s+(GRN_OP_\w+)/
-    operator = $1
-    rb_operator = operator.gsub(/\AGRN_OP_/, "").split("_").map{ |word|
-      replace_dictionary[word] || word
-    }.join("_")
-    puts "    rb_define_const(rb_mGrnOperation, \"%s\",
-                    UINT2NUM(%s));" % [rb_operator, operator]
-  end
-end

data/pkg-config.rb

@@ -1,333 +0,0 @@
-# Copyright 2008-2009 Kouhei Sutou <kou@cozmixng.org>
-# This file is made available under the same terms as Ruby.
-
-require "rbconfig"
-
-require 'mkmf'
-require 'shellwords'
-require 'English'
-require 'pathname'
-
-class PackageConfig
-  @@default_prepend_paths = []
-  @@default_append_paths = []
-
-  class << self
-    def prepend_default_path(path)
-      @@default_prepend_paths.unshift(path)
-    end
-
-    def append_default_path(path)
-      @@default_append_paths << path
-    end
-  end
-
-  attr_accessor :msvc_syntax
-  def initialize(name, path=nil, msvc_syntax=false)
-    @name = name
-    @path = path || ENV["PKG_CONFIG_PATH"]
-    @path = [@path, guess_default_path].compact.join(separator)
-    @msvc_syntax = msvc_syntax
-    @variables = @declarations = nil
-    override_variables = with_config("override-variables", "")
-    @override_variables = parse_override_variables(override_variables)
-  end
-
-  def exist?
-    not pc.nil?
-  end
-
-  def requires
-    parse_requires(declaration("Requires"))
-  end
-
-  def requires_private
-    parse_requires(declaration("Requires.private"))
-  end
-
-  def cflags
-    path_flags, other_flags = collect_cflags
-    (other_flags + path_flags).join(" ")
-  end
-
-  def cflags_only_I
-    collect_cflags[0].join(" ")
-  end
-
-  def libs
-    path_flags, other_flags = collect_libs
-    (other_flags + path_flags).join(" ")
-  end
-
-  def libs_only_l
-    collect_libs[1].find_all do |arg|
-      if @msvc_syntax
-        /\.lib\z/ =~ arg
-      else
-        /\A-l/ =~ arg
-      end
-    end.join(" ")
-  end
-
-  def version
-    declaration("Version")
-  end
-
-  def variable(name)
-    parse_pc if @variables.nil?
-    expand_value(@override_variables[name] || @variables[name])
-  end
-
-  def declaration(name)
-    parse_pc if @declarations.nil?
-    expand_value(@declarations[name])
-  end
-
-  private
-  def paths
-    paths = @@default_prepend_paths
-    paths += @path.split(separator)
-    paths += @@default_append_paths
-    paths
-  end
-
-  def pc
-    paths.each do |path|
-      pc_name = File.join(path, "#{@name}.pc")
-      return pc_name if File.exist?(pc_name)
-    end
-    return nil
-  end
-
-  def separator
-    File.expand_path(".").index(":") ? ";" : ":"
-  end
-
-  def collect_cflags
-    all_cflags = (requires_private + requires.reverse).collect do |package|
-      self.class.new(package, @path, @msvc_syntax).cflags
-    end
-    all_cflags = [declaration("Cflags")] + all_cflags
-    all_cflags = all_cflags.join(" ").gsub(/-I /, '-I').split.uniq
-    path_flags, other_flags = all_cflags.partition {|flag| /\A-I/ =~ flag}
-    path_flags = path_flags.reject do |flag|
-      flag == "-I/usr/include"
-    end
-    if @msvc_syntax
-      path_flags = path_flags.collect do |flag|
-        flag.gsub(/\A-I/, "/I")
-      end
-    end
-    [path_flags, other_flags]
-  end
-
-  def collect_libs
-    all_libs = requires.collect do |package|
-      self.class.new(package, @path, @msvc_syntax).libs
-    end
-    all_libs = [declaration("Libs")] + all_libs
-    all_libs = all_libs.join(" ").gsub(/-([Ll]) /, '\1').split.uniq
-    path_flags, other_flags = all_libs.partition {|flag| /\A-L/ =~ flag}
-    path_flags = path_flags.reject do |flag|
-      /\A-L\/usr\/lib(?:64)?\z/ =~ flag
-    end
-    if @msvc_syntax
-      path_flags = path_flags.collect do |flag|
-        flag.gsub(/\A-L/, "/libpath:")
-      end
-      other_flags = other_flags.collect do |flag|
-        if /\A-l/ =~ flag
-          "#{$POSTMATCH}.lib"
-        else
-          flag
-        end
-      end
-    end
-    [path_flags, other_flags]
-  end
-
-  IDENTIFIER_RE = /[\w.]+/
-  def parse_pc
-    raise ".pc for #{@name} doesn't exist." unless exist?
-    @variables = {}
-    @declarations = {}
-    File.open(pc) do |input|
-      input.each_line do |line|
-        line = line.gsub(/#.*/, '').strip
-        next if line.empty?
-        case line
-        when /^(#{IDENTIFIER_RE})=/
-          @variables[$1] = $POSTMATCH.strip
-        when /^(#{IDENTIFIER_RE}):/
-          @declarations[$1] = $POSTMATCH.strip
-        end
-      end
-    end
-  end
-
-  def parse_requires(requires)
-    return [] if requires.nil?
-    requires_without_version = requires.gsub(/[<>]?=\s*[\d.]+\s*/, '')
-    requires_without_version.split(/[,\s]+/)
-  end
-
-  def parse_override_variables(override_variables)
-    variables = {}
-    override_variables.split(",").each do |variable|
-      name, value = variable.split("=", 2)
-      variables[name] = value
-    end
-    variables
-  end
-
-  def expand_value(value)
-    return nil if value.nil?
-    value.gsub(/\$\{(#{IDENTIFIER_RE})\}/) do
-      variable($1)
-    end
-  end
-
-  def search_pkg_config_from_path(pkg_config)
-    (ENV["PATH"] || "").split(separator).each do |path|
-      try_pkg_config = Pathname(path) + pkg_config
-      return try_pkg_config if try_pkg_config.exist?
-    end
-    nil
-  end
-
-  def search_pkg_config_by_dln_find_exe(pkg_config)
-    begin
-      require "dl/import"
-    rescue LoadError
-      return nil
-    end
-    dln = Module.new
-    dln.module_eval do
-      if DL.const_defined?(:Importer)
-        extend DL::Importer
-      else
-        extend DL::Importable
-      end
-      begin
-        dlload RbConfig::CONFIG["LIBRUBY"]
-      rescue RuntimeError
-        return nil if $!.message == "unknown error"
-        return nil if /: image not found\z/ =~ $!.message
-        raise
-      rescue DL::DLError
-        return nil
-      end
-      extern "const char *dln_find_exe(const char *, const char *)"
-    end
-    path = dln.dln_find_exe(pkg_config.to_s, nil)
-    if path.size.zero?
-      nil
-    else
-      Pathname(path.to_s)
-    end
-  end
-
-  def guess_default_path
-    default_path = ["/usr/local/lib64/pkgconfig",
-                    "/usr/local/lib/pkgconfig",
-                    "/usr/local/libdata/pkgconfig",
-                    "/opt/local/lib/pkgconfig",
-                    "/usr/lib64/pkgconfig",
-                    "/usr/lib/pkgconfig",
-                    "/usr/X11/lib/pkgconfig/",
-                    "/usr/share/pkgconfig"].join(separator)
-    libdir = ENV["PKG_CONFIG_LIBDIR"]
-    default_path = [libdir, default_path].join(separator) if libdir
-
-    pkg_config = with_config("pkg-config", ENV["PKG_CONFIG"] || "pkg-config")
-    pkg_config = Pathname.new(pkg_config)
-    unless pkg_config.absolute?
-      found_pkg_config = search_pkg_config_from_path(pkg_config)
-      pkg_config = found_pkg_config if found_pkg_config
-    end
-    unless pkg_config.absolute?
-      found_pkg_config = search_pkg_config_by_dln_find_exe(pkg_config)
-      pkg_config = found_pkg_config if found_pkg_config
-    end
-
-    return default_path unless pkg_config.absolute?
-    [(pkg_config.parent.parent + "lib" + "pkgconfig").to_s,
-     (pkg_config.parent.parent + "libdata" + "pkgconfig").to_s,
-     default_path].join(separator)
-  end
-end
-
-module PKGConfig
-  module_function
-  def msvc?
-    /mswin32/.match(RUBY_PLATFORM) and /^cl\b/.match(Config::CONFIG['CC'])
-  end
-
-  def package_config(package)
-    PackageConfig.new(package, nil, msvc?)
-  end
-
-  def exist?(pkg)
-    package_config(pkg).exist?
-  end
-
-  def libs(pkg)
-    package_config(pkg).libs
-  end
-
-  def libs_only_l(pkg)
-    package_config(pkg).libs_only_l
-  end
-
-  def cflags(pkg)
-    package_config(pkg).cflags
-  end
-
-  def cflags_only_I(pkg)
-    package_config(pkg).cflags_only_I
-  end
-
-  def modversion(pkg)
-    package_config(pkg).version
-  end
-
-  def check_version?(pkg, major = 0, minor = 0, micro = 0)
-    return false unless exist?(pkg)
-    ver = modversion(pkg).split(".").collect{|item| item.to_i}
-    (0..2).each {|i| ver[i] = 0 unless ver[i]}
-
-    (ver[0] > major ||
-     (ver[0] == major && ver[1] > minor) ||
-     (ver[0] == major && ver[1] == minor &&
-      ver[2] >= micro))
-  end
-
-  def have_package(pkg, major = nil, minor = 0, micro = 0)
-    if major.nil?
-      STDOUT.print("checking for #{pkg}... ")
-    else
-      STDOUT.print("checking for #{pkg} version (>= #{major}.#{minor}.#{micro})... ")
-    end
-    major ||= 0
-    STDOUT.flush
-    if check_version?(pkg, major, minor, micro)
-      STDOUT.print "yes\n"
-      libraries = libs_only_l(pkg)
-      dldflags = libs(pkg)
-      dldflags = (Shellwords.shellwords(dldflags) -
-                  Shellwords.shellwords(libraries))
-      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
-      $libs   += ' ' + libraries
-      if /mswin32/ =~ RUBY_PLATFORM
-	$DLDFLAGS += ' ' + dldflags
-      else
-	$LDFLAGS += ' ' + dldflags
-      end
-      $CFLAGS += ' ' + cflags(pkg)
-      true
-    else
-      STDOUT.print "no\n"
-      false
-    end
-  end
-end

data/src/rb-grn-table-cursor.c

@@ -1,296 +0,0 @@
-/* -*- c-file-style: "ruby" -*- */
-/*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License version 2.1 as published by the Free Software Foundation.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "rb-grn.h"
-
-#define SELF(object) (rb_rb_grn_table_cursor_from_ruby_object(object))
-
-typedef struct _RbGrnTableCursor RbGrnTableCursor;
-struct _RbGrnTableCursor
-{
-    grn_ctx *context;
-    grn_table_cursor *cursor;
-    rb_grn_boolean owner;
-};
-
-VALUE rb_cGrnTableCursor;
-
-static RbGrnTableCursor *
-rb_rb_grn_table_cursor_from_ruby_object (VALUE object)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnTableCursor))) {
-	rb_raise(rb_eTypeError, "not a groonga table cursor");
-    }
-
-    Data_Get_Struct(object, RbGrnTableCursor, rb_grn_table_cursor);
-    if (!rb_grn_table_cursor)
-	rb_raise(rb_eGrnError, "groonga table cursor is NULL");
-
-    return rb_grn_table_cursor;
-}
-
-grn_table_cursor *
-rb_grn_table_cursor_from_ruby_object (VALUE object)
-{
-    if (NIL_P(object))
-        return NULL;
-
-    return SELF(object)->cursor;
-}
-
-static void
-rb_rb_grn_table_cursor_free (void *object)
-{
-    RbGrnTableCursor *rb_grn_table_cursor = object;
-
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor &&
-	rb_grn_table_cursor->owner) {
-	printf("close!\n");
-	grn_table_cursor_close(rb_grn_table_cursor->context,
-			       rb_grn_table_cursor->cursor);
-    }
-    xfree(object);
-}
-
-VALUE
-rb_grn_table_cursor_to_ruby_class (grn_obj *object)
-{
-    VALUE klass = Qnil;
-
-    switch (object->header.type) {
-      case GRN_CURSOR_TABLE_HASH_KEY:
-	klass = rb_cGrnHashCursor;
-	break;
-      case GRN_CURSOR_TABLE_PAT_KEY:
-	klass = rb_cGrnPatriciaTrieCursor;
-	break;
-      case GRN_CURSOR_TABLE_NO_KEY:
-	klass = rb_cGrnArrayCursor;
-	break;
-      default:
-	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: %d",
-		 object->header.type);
-	break;
-    }
-
-    return klass;
-}
-
-VALUE
-rb_grn_table_cursor_to_ruby_object (VALUE klass, grn_ctx *context,
-                                    grn_table_cursor *cursor)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    if (!cursor)
-        return Qnil;
-
-    rb_grn_table_cursor = ALLOC(RbGrnTableCursor);
-    rb_grn_table_cursor->context = context;
-    rb_grn_table_cursor->cursor = cursor;
-    rb_grn_table_cursor->owner = RB_GRN_TRUE; /* FIXME */
-
-    if (NIL_P(klass))
-        klass = GRNTABLECURSOR2RCLASS(cursor);
-
-    return Data_Wrap_Struct(klass, NULL,
-                            rb_rb_grn_table_cursor_free, rb_grn_table_cursor);
-}
-
-static VALUE
-rb_grn_table_cursor_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_table_cursor_free, NULL);
-}
-
-grn_ctx *
-rb_grn_table_cursor_ensure_context (VALUE cursor, VALUE rb_context)
-{
-    if (NIL_P(rb_context)) {
-	RbGrnTableCursor *rb_grn_table_cursor;
-
-	rb_grn_table_cursor = SELF(cursor);
-	if (rb_grn_table_cursor && rb_grn_table_cursor->context)
-	    return rb_grn_table_cursor->context;
-    }
-
-    return rb_grn_context_ensure(rb_context);
-}
-
-VALUE
-rb_grn_table_cursor_close (VALUE self)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        grn_rc rc = GRN_SUCCESS;
-
-	if (rb_grn_table_cursor->owner)
-	    rc = grn_table_cursor_close(rb_grn_table_cursor->context,
-					rb_grn_table_cursor->cursor);
-        rb_grn_table_cursor->context = NULL;
-        rb_grn_table_cursor->cursor = NULL;
-	rb_grn_table_cursor->owner = RB_GRN_FALSE;
-        rb_grn_rc_check(rc, self);
-    }
-    return Qnil;
-}
-
-static VALUE
-rb_grn_table_cursor_closed_p (VALUE self)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor)
-        return Qfalse;
-    else
-        return Qtrue;
-}
-
-static VALUE
-rb_grn_table_cursor_get_value (VALUE self)
-{
-    VALUE rb_value = Qnil;
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        int n;
-        void *value;
-
-        n = grn_table_cursor_get_value(rb_grn_table_cursor->context,
-                                       rb_grn_table_cursor->cursor,
-                                       &value);
-        rb_value = rb_str_new(value, n);
-    }
-
-    return rb_value;
-}
-
-static VALUE
-rb_grn_table_cursor_set_value (VALUE self, VALUE value)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        grn_rc rc;
-
-        rc = grn_table_cursor_set_value(rb_grn_table_cursor->context,
-                                        rb_grn_table_cursor->cursor,
-                                        StringValuePtr(value), GRN_OBJ_SET);
-        rb_grn_rc_check(rc, self);
-    }
-
-    return Qnil;
-}
-
-static VALUE
-rb_grn_table_cursor_delete (VALUE self)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        grn_rc rc;
-
-        rc = grn_table_cursor_delete(rb_grn_table_cursor->context,
-                                     rb_grn_table_cursor->cursor);
-        rb_grn_rc_check(rc, self);
-    }
-
-    return Qnil;
-}
-
-static VALUE
-rb_grn_table_cursor_next (VALUE self)
-{
-    VALUE rb_record = Qnil;
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        grn_id record_id;
-
-        record_id = grn_table_cursor_next(rb_grn_table_cursor->context,
-                                          rb_grn_table_cursor->cursor);
-        if (record_id != GRN_ID_NIL) /* FIXME: use grn_table_cursor_table */
-            rb_record = rb_grn_record_new(rb_iv_get(self, "@table"), record_id);
-    }
-
-    return rb_record;
-}
-
-static VALUE
-rb_grn_table_cursor_each (VALUE self)
-{
-    grn_id record_id;
-    RbGrnTableCursor *rb_grn_table_cursor;
-    grn_ctx *context;
-    grn_table_cursor *cursor;
-
-    rb_grn_table_cursor = SELF(self);
-    if (!rb_grn_table_cursor->context)
-        return Qnil;
-    if (!rb_grn_table_cursor->cursor)
-        return Qnil;
-
-    context = rb_grn_table_cursor->context;
-    cursor = rb_grn_table_cursor->cursor;
-    while ((record_id = grn_table_cursor_next(context, cursor))) {
-        rb_yield(rb_grn_record_new(rb_iv_get(self, "@table"), record_id));
-    }
-
-    return Qnil;
-}
-
-void
-rb_grn_init_table_cursor (VALUE mGrn)
-{
-    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCurosr", rb_cObject);
-    rb_define_alloc_func(rb_cGrnTableCursor, rb_grn_table_cursor_alloc);
-
-    rb_include_module(rb_cGrnTableCursor, rb_mEnumerable);
-
-    rb_define_method(rb_cGrnTableCursor, "close",
-                     rb_grn_table_cursor_close, 0);
-    rb_define_method(rb_cGrnTableCursor, "closed?",
-                     rb_grn_table_cursor_closed_p, 0);
-
-    rb_define_method(rb_cGrnTableCursor, "value",
-                     rb_grn_table_cursor_get_value, 0);
-    rb_define_method(rb_cGrnTableCursor, "value=",
-                     rb_grn_table_cursor_set_value, 1);
-    rb_define_method(rb_cGrnTableCursor, "delete",
-                     rb_grn_table_cursor_delete, 0);
-    rb_define_method(rb_cGrnTableCursor, "next",
-                     rb_grn_table_cursor_next, 0);
-
-    rb_define_method(rb_cGrnTableCursor, "each",
-                     rb_grn_table_cursor_each, 0);
-
-    rb_grn_init_table_cursor_key_support(mGrn);
-    rb_grn_init_array_cursor(mGrn);
-    rb_grn_init_hash_cursor(mGrn);
-    rb_grn_init_patricia_trie_cursor(mGrn);
-}