rroonga 6.0.7-x86-mingw32 → 6.0.9-x86-mingw32

data/vendor/local/include/pcrecpparg.h

@@ -0,0 +1,174 @@
+// Copyright (c) 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: Sanjay Ghemawat
+
+#ifndef _PCRECPPARG_H
+#define _PCRECPPARG_H
+
+#include <stdlib.h>    // for NULL
+#include <string>
+
+#include <pcre.h>
+
+namespace pcrecpp {
+
+class StringPiece;
+
+// Hex/Octal/Binary?
+
+// Special class for parsing into objects that define a ParseFrom() method
+template <class T>
+class _RE_MatchObject {
+ public:
+  static inline bool Parse(const char* str, int n, void* dest) {
+    if (dest == NULL) return true;
+    T* object = reinterpret_cast<T*>(dest);
+    return object->ParseFrom(str, n);
+  }
+};
+
+class PCRECPP_EXP_DEFN Arg {
+ public:
+  // Empty constructor so we can declare arrays of Arg
+  Arg();
+
+  // Constructor specially designed for NULL arguments
+  Arg(void*);
+
+  typedef bool (*Parser)(const char* str, int n, void* dest);
+
+// Type-specific parsers
+#define PCRE_MAKE_PARSER(type,name)                             \
+  Arg(type* p) : arg_(p), parser_(name) { }                     \
+  Arg(type* p, Parser parser) : arg_(p), parser_(parser) { }
+
+
+  PCRE_MAKE_PARSER(char,               parse_char);
+  PCRE_MAKE_PARSER(unsigned char,      parse_uchar);
+  PCRE_MAKE_PARSER(short,              parse_short);
+  PCRE_MAKE_PARSER(unsigned short,     parse_ushort);
+  PCRE_MAKE_PARSER(int,                parse_int);
+  PCRE_MAKE_PARSER(unsigned int,       parse_uint);
+  PCRE_MAKE_PARSER(long,               parse_long);
+  PCRE_MAKE_PARSER(unsigned long,      parse_ulong);
+#if 1
+  PCRE_MAKE_PARSER(long long,          parse_longlong);
+#endif
+#if 1
+  PCRE_MAKE_PARSER(unsigned long long, parse_ulonglong);
+#endif
+  PCRE_MAKE_PARSER(float,              parse_float);
+  PCRE_MAKE_PARSER(double,             parse_double);
+  PCRE_MAKE_PARSER(std::string,        parse_string);
+  PCRE_MAKE_PARSER(StringPiece,        parse_stringpiece);
+
+#undef PCRE_MAKE_PARSER
+
+  // Generic constructor
+  template <class T> Arg(T*, Parser parser);
+  // Generic constructor template
+  template <class T> Arg(T* p)
+    : arg_(p), parser_(_RE_MatchObject<T>::Parse) {
+  }
+
+  // Parse the data
+  bool Parse(const char* str, int n) const;
+
+ private:
+  void*         arg_;
+  Parser        parser_;
+
+  static bool parse_null          (const char* str, int n, void* dest);
+  static bool parse_char          (const char* str, int n, void* dest);
+  static bool parse_uchar         (const char* str, int n, void* dest);
+  static bool parse_float         (const char* str, int n, void* dest);
+  static bool parse_double        (const char* str, int n, void* dest);
+  static bool parse_string        (const char* str, int n, void* dest);
+  static bool parse_stringpiece   (const char* str, int n, void* dest);
+
+#define PCRE_DECLARE_INTEGER_PARSER(name)                                   \
+ private:                                                                   \
+  static bool parse_ ## name(const char* str, int n, void* dest);           \
+  static bool parse_ ## name ## _radix(                                     \
+    const char* str, int n, void* dest, int radix);                         \
+ public:                                                                    \
+  static bool parse_ ## name ## _hex(const char* str, int n, void* dest);   \
+  static bool parse_ ## name ## _octal(const char* str, int n, void* dest); \
+  static bool parse_ ## name ## _cradix(const char* str, int n, void* dest)
+
+  PCRE_DECLARE_INTEGER_PARSER(short);
+  PCRE_DECLARE_INTEGER_PARSER(ushort);
+  PCRE_DECLARE_INTEGER_PARSER(int);
+  PCRE_DECLARE_INTEGER_PARSER(uint);
+  PCRE_DECLARE_INTEGER_PARSER(long);
+  PCRE_DECLARE_INTEGER_PARSER(ulong);
+  PCRE_DECLARE_INTEGER_PARSER(longlong);
+  PCRE_DECLARE_INTEGER_PARSER(ulonglong);
+
+#undef PCRE_DECLARE_INTEGER_PARSER
+};
+
+inline Arg::Arg() : arg_(NULL), parser_(parse_null) { }
+inline Arg::Arg(void* p) : arg_(p), parser_(parse_null) { }
+
+inline bool Arg::Parse(const char* str, int n) const {
+  return (*parser_)(str, n, arg_);
+}
+
+// This part of the parser, appropriate only for ints, deals with bases
+#define MAKE_INTEGER_PARSER(type, name) \
+  inline Arg Hex(type* ptr) { \
+    return Arg(ptr, Arg::parse_ ## name ## _hex); } \
+  inline Arg Octal(type* ptr) { \
+    return Arg(ptr, Arg::parse_ ## name ## _octal); } \
+  inline Arg CRadix(type* ptr) { \
+    return Arg(ptr, Arg::parse_ ## name ## _cradix); }
+
+MAKE_INTEGER_PARSER(short,              short)     /*                        */
+MAKE_INTEGER_PARSER(unsigned short,     ushort)    /*                        */
+MAKE_INTEGER_PARSER(int,                int)       /* Don't use semicolons   */
+MAKE_INTEGER_PARSER(unsigned int,       uint)      /* after these statement  */
+MAKE_INTEGER_PARSER(long,               long)      /* because they can cause */
+MAKE_INTEGER_PARSER(unsigned long,      ulong)     /* compiler warnings if   */
+#if 1                          /* the checking level is  */
+MAKE_INTEGER_PARSER(long long,          longlong)  /* turned up high enough. */
+#endif                                             /*                        */
+#if 1                         /*                        */
+MAKE_INTEGER_PARSER(unsigned long long, ulonglong) /*                        */
+#endif
+
+#undef PCRE_IS_SET
+#undef PCRE_SET_OR_CLEAR
+#undef MAKE_INTEGER_PARSER
+
+}   // namespace pcrecpp
+
+
+#endif /* _PCRECPPARG_H */

data/vendor/local/include/pcreposix.h

@@ -0,0 +1,146 @@
+/*************************************************
+*       Perl-Compatible Regular Expressions      *
+*************************************************/
+
+#ifndef _PCREPOSIX_H
+#define _PCREPOSIX_H
+
+/* This is the header for the POSIX wrapper interface to the PCRE Perl-
+Compatible Regular Expression library. It defines the things POSIX says should
+be there. I hope.
+
+            Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+/* Have to include stdlib.h in order to ensure that size_t is defined. */
+
+#include <stdlib.h>
+
+/* Allow for C++ users */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Options, mostly defined by POSIX, but with some extras. */
+
+#define REG_ICASE     0x0001   /* Maps to PCRE_CASELESS */
+#define REG_NEWLINE   0x0002   /* Maps to PCRE_MULTILINE */
+#define REG_NOTBOL    0x0004   /* Maps to PCRE_NOTBOL */
+#define REG_NOTEOL    0x0008   /* Maps to PCRE_NOTEOL */
+#define REG_DOTALL    0x0010   /* NOT defined by POSIX; maps to PCRE_DOTALL */
+#define REG_NOSUB     0x0020   /* Maps to PCRE_NO_AUTO_CAPTURE */
+#define REG_UTF8      0x0040   /* NOT defined by POSIX; maps to PCRE_UTF8 */
+#define REG_STARTEND  0x0080   /* BSD feature: pass subject string by so,eo */
+#define REG_NOTEMPTY  0x0100   /* NOT defined by POSIX; maps to PCRE_NOTEMPTY */
+#define REG_UNGREEDY  0x0200   /* NOT defined by POSIX; maps to PCRE_UNGREEDY */
+#define REG_UCP       0x0400   /* NOT defined by POSIX; maps to PCRE_UCP */
+
+/* This is not used by PCRE, but by defining it we make it easier
+to slot PCRE into existing programs that make POSIX calls. */
+
+#define REG_EXTENDED  0
+
+/* Error values. Not all these are relevant or used by the wrapper. */
+
+enum {
+  REG_ASSERT = 1,  /* internal error ? */
+  REG_BADBR,       /* invalid repeat counts in {} */
+  REG_BADPAT,      /* pattern error */
+  REG_BADRPT,      /* ? * + invalid */
+  REG_EBRACE,      /* unbalanced {} */
+  REG_EBRACK,      /* unbalanced [] */
+  REG_ECOLLATE,    /* collation error - not relevant */
+  REG_ECTYPE,      /* bad class */
+  REG_EESCAPE,     /* bad escape sequence */
+  REG_EMPTY,       /* empty expression */
+  REG_EPAREN,      /* unbalanced () */
+  REG_ERANGE,      /* bad range inside [] */
+  REG_ESIZE,       /* expression too big */
+  REG_ESPACE,      /* failed to get memory */
+  REG_ESUBREG,     /* bad back reference */
+  REG_INVARG,      /* bad argument */
+  REG_NOMATCH      /* match failed */
+};
+
+
+/* The structure representing a compiled regular expression. */
+
+typedef struct {
+  void *re_pcre;
+  size_t re_nsub;
+  size_t re_erroffset;
+} regex_t;
+
+/* The structure in which a captured offset is returned. */
+
+typedef int regoff_t;
+
+typedef struct {
+  regoff_t rm_so;
+  regoff_t rm_eo;
+} regmatch_t;
+
+/* When an application links to a PCRE DLL in Windows, the symbols that are
+imported have to be identified as such. When building PCRE, the appropriate
+export settings are needed, and are set in pcreposix.c before including this
+file. */
+
+#if defined(_WIN32) && !defined(PCRE_STATIC) && !defined(PCREPOSIX_EXP_DECL)
+#  define PCREPOSIX_EXP_DECL  extern __declspec(dllimport)
+#  define PCREPOSIX_EXP_DEFN  __declspec(dllimport)
+#endif
+
+/* By default, we use the standard "extern" declarations. */
+
+#ifndef PCREPOSIX_EXP_DECL
+#  ifdef __cplusplus
+#    define PCREPOSIX_EXP_DECL  extern "C"
+#    define PCREPOSIX_EXP_DEFN  extern "C"
+#  else
+#    define PCREPOSIX_EXP_DECL  extern
+#    define PCREPOSIX_EXP_DEFN  extern
+#  endif
+#endif
+
+/* The functions */
+
+PCREPOSIX_EXP_DECL int regcomp(regex_t *, const char *, int);
+PCREPOSIX_EXP_DECL int regexec(const regex_t *, const char *, size_t,
+                     regmatch_t *, int);
+PCREPOSIX_EXP_DECL size_t regerror(int, const regex_t *, char *, size_t);
+PCREPOSIX_EXP_DECL void regfree(regex_t *);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif /* End of pcreposix.h */

data/vendor/local/lib/groonga/plugins/sharding/logical_table_remove.rb

@@ -10,10 +10,12 @@ module Groonga
                  "max",
                  "max_border",
                  "dependent",
+                 "force",
                ])
 
       def run_body(input)
         @dependent = (input[:dependent] == "yes")
+        @force = (input[:force] == "yes")
 
         enumerator = LogicalEnumerator.new("logical_table_remove", input)
 
@@ -30,65 +32,293 @@ module Groonga
         return if cover_type == :none
 
         shard_key = shard.key
-        if shard_key.nil?
+        if shard_key.nil? and !@force
           message = "[logical_table_remove] shard_key doesn't exist: " +
                     "<#{shard.key_name}>"
           raise InvalidArgument, message
         end
         table = shard.table
 
+        if cover_type == :all or ((table.nil? or shard_key.nil?) and @force)
+          remove_table(shard, table)
+          return
+        end
+
         expression_builder = RangeExpressionBuilder.new(shard_key,
                                                         target_range,
                                                         nil)
-
         case cover_type
-        when :all
-          remove_table(shard)
         when :partial_min
           remove_records(table) do |expression|
             expression_builder.build_partial_min(expression)
           end
-          remove_table(shard) if table.empty?
+          remove_table(shard, table) if table.empty?
         when :partial_max
           remove_records(table) do |expression|
             expression_builder.build_partial_max(expression)
           end
-          remove_table(shard) if table.empty?
+          remove_table(shard, table) if table.empty?
         when :partial_min_and_max
           remove_records(table) do |expression|
             expression_builder.build_partial_min_and_max(expression)
           end
-          remove_table(shard) if table.empty?
+          remove_table(shard, table) if table.empty?
         end
       end
 
-      def remove_table(shard)
-        table = shard.table
-        shard_suffix = shard.range_data.to_suffix
+      def collect_referenced_table_ids_from_index_ids(index_ids,
+                                                      referenced_table_ids)
+        database = context.database
+        index_ids.each do |index_id|
+          index = context[index_id]
+          if index.nil?
+            context.clear_error
+            index_name = database[index_id]
+            lexicon_name = index_name.split(".", 2)[0]
+            lexicon_id = database[lexicon_name]
+            referenced_table_ids << lexicon_id if lexicon_id
+          else
+            referenced_table_ids << index.domain_id
+          end
+        end
+      end
+
+      def collect_referenced_table_ids_from_column_name(column_name,
+                                                        referenced_table_ids)
+        database = context.database
+        column_id = database[column_name]
+        database.each_raw do |id, cursor|
+          next if ID.builtin?(id)
+          next if id == column_id
+
+          context.open_temporary(id) do |object|
+            if object.nil?
+              context.clear_error
+              next
+            end
+
+            case object
+            when IndexColumn
+              if object.source_ids.include?(column_id)
+                collect_referenced_table_ids_from_index_ids([id],
+                                                            referenced_table_ids)
+              end
+            end
+          end
+        end
+      end
+
+      def collect_referenced_table_ids_from_column(column,
+                                                   referenced_table_ids)
+        range = column.range
+        case range
+        when nil
+          context.clear_error
+        when Table
+          referenced_table_ids << range.id
+          collect_referenced_table_ids_from_index_ids(range.index_ids,
+                                                      referenced_table_ids)
+        end
+        collect_referenced_table_ids_from_index_ids(column.index_ids,
+                                                    referenced_table_ids)
+      end
 
+      def collect_referenced_table_ids_from_column_names(column_names)
         referenced_table_ids = []
-        if @dependent
-          table.columns.each do |column|
-            range = column.range
-            if range.is_a?(Table)
-              referenced_table_ids << range.id
-              range.indexes.each do |index_info|
-                referenced_table_ids << index_info.index.domain.id
+        column_names.each do |column_name|
+          column = context[column_name]
+          if column.nil?
+            context.clear_error
+            collect_referenced_table_ids_from_column_name(column_name,
+                                                          referenced_table_ids)
+          else
+            collect_referenced_table_ids_from_column(column,
+                                                     referenced_table_ids)
+          end
+        end
+        referenced_table_ids
+      end
+
+      def collect_referenced_table_ids(shard, table)
+        return [] unless @dependent
+
+        column_names = nil
+        if table
+          begin
+            column_names = table.columns.collect(&:name)
+          rescue
+            context.clear_error
+          end
+        end
+        if column_names.nil?
+          prefix = "#{shard.table_name}."
+          column_names = []
+          context.database.each_name(:prefix => prefix) do |column_name|
+            column_names << column_name
+          end
+        end
+
+        collect_referenced_table_ids_from_column_names(column_names)
+      end
+
+      def remove_table(shard, table)
+        if table.nil?
+          unless @force
+            if context.rc == Context::RC::SUCCESS.to_i
+              error_class = InvalidArgument
+            else
+              rc = Context::RC.find(context.rc)
+              error_class = rc.error_class
+            end
+            message = "[logical_table_remove] table is broken: " +
+                      "<#{shard.table_name}>: #{context.error_message}"
+            raise error_class, message
+          end
+          context.clear_error
+        end
+
+        referenced_table_ids = collect_referenced_table_ids(shard, table)
+
+        if table.nil?
+          remove_table_force(shard.table_name)
+        else
+          options = {:dependent => @dependent}
+          if @force
+            begin
+              table.remove(options)
+            rescue
+              context.clear_error
+              table.close
+              remove_table_force(shard.table_name)
+            end
+          else
+            table.remove(options)
+          end
+        end
+
+        remove_referenced_tables(shard, referenced_table_ids)
+      end
+
+      def remove_table_force(table_name)
+        database = context.database
+
+        prefix = "#{table_name}."
+        database.each_raw(:prefix => prefix) do |id, cursor|
+          column = context[id]
+          if column.nil?
+            context.clear_error
+            column_name = cursor.key
+            remove_column_force(column_name)
+            table = context[table_name]
+            if table.nil?
+              context.clear_error
+            else
+              table.close
+            end
+          else
+            remove_column(column)
+          end
+        end
+
+        table_id = database[table_name]
+        return if table_id.nil?
+
+        database.each_raw do |id, cursor|
+          next if ID.builtin?(id)
+          next if id == table_id
+
+          context.open_temporary(id) do |object|
+            if object.nil?
+              context.clear_error
+              next
+            end
+
+            case object
+            when Table
+              if object.domain_id == table_id
+                begin
+                  object.remove(:dependent => @dependent)
+                rescue
+                  context.clear_error
+                  reference_table_name = object.name
+                  object.close
+                  remove_table_force(reference_table_name)
+                end
+              end
+            when Column
+              if object.range_id == table_id
+                remove_column(object)
               end
             end
-            column.indexes.each do |index_info|
-              referenced_table_ids << index_info.index.domain.id
+          end
+        end
+
+        Object.remove_force(table_name)
+      end
+
+      def remove_column(column)
+        begin
+          column.remove(:dependent => @dependent)
+        rescue
+          context.clear_error
+          column_name = column.name
+          column.close
+          remove_column_force(column_name)
+        end
+      end
+
+      def remove_column_force(column_name)
+        database = context.database
+
+        column_id = database[column_name]
+
+        column = context[column_id]
+        if column.nil?
+          context.clear_error
+        else
+          column.index_ids.each do |id|
+            index_column = context[id]
+            if index_column.nil?
+              context.clear_error
+              index_column_name = database[id]
+              remove_column_force(index_column_name)
+            else
+              remove_column(index_column)
             end
           end
+          column.close
         end
 
-        table.remove(:dependent => @dependent)
+        Object.remove_force(column_name)
+      end
+
+      def remove_referenced_tables(shard, referenced_table_ids)
+        return if referenced_table_ids.empty?
 
-        context = Groonga::Context.instance
+        database = context.database
+        shard_suffix = shard.range_data.to_suffix
         referenced_table_ids.each do |referenced_table_id|
+          referenced_table_name = database[referenced_table_id]
+          next unless referenced_table_name.end_with?(shard_suffix)
+
           referenced_table = context[referenced_table_id]
-          next if referenced_table.nil?
-          if referenced_table.name.end_with?(shard_suffix)
+          if referenced_table.nil?
+            context.clear_error
+            if @force
+              Object.remove_force(referenced_table_name)
+            end
+            next
+          end
+
+          if @force
+            begin
+              referenced_table.remove(:dependent => @dependent)
+            rescue
+              context.clear_error
+              referenced_table.close
+              remove_table_force(referenced_table_name)
+            end
+          else
             referenced_table.remove(:dependent => @dependent)
           end
         end