extralite-bundle 3.0.1 → 3.1.1

data/ext/extralite/database.c

@@ -19,6 +19,7 @@ VALUE cParameterError;
 VALUE eArgumentError;
 
 ID ID_bind;
+ID ID_inspect;
 ID ID_call;
 ID ID_each;
 ID ID_keys;
@@ -38,6 +39,7 @@ VALUE SYM_normal;
 VALUE SYM_passive;
 VALUE SYM_read_only;
 VALUE SYM_restart;
+VALUE SYM_stmt_cache;
 VALUE SYM_truncate;
 VALUE SYM_wal;
 
@@ -58,19 +60,39 @@ static size_t Database_size(const void *ptr) {
 
 static void Database_mark(void *ptr) {
   Database_t *db = ptr;
+  rb_gc_mark_movable(db->stmt_cache);
   rb_gc_mark_movable(db->trace_proc);
   rb_gc_mark_movable(db->progress_handler.proc);
 }
 
 static void Database_compact(void *ptr) {
   Database_t *db = ptr;
+  db->stmt_cache            = rb_gc_location(db->stmt_cache);
   db->trace_proc            = rb_gc_location(db->trace_proc);
   db->progress_handler.proc = rb_gc_location(db->progress_handler.proc);
 }
 
+static int stmt_cache_iter(VALUE key, VALUE value, VALUE _param) {
+  sqlite3_stmt *stmt = (sqlite3_stmt *)NUM2ULONG(value);
+  sqlite3_finalize(stmt);
+  return ST_CONTINUE;
+}
+
+static void stmt_cache_clear(sqlite3 *db, VALUE stmt_cache) {
+  if (stmt_cache == Qnil) return;
+  if (rb_hash_size_num(stmt_cache) == 0) return;
+
+  rb_hash_foreach(stmt_cache, stmt_cache_iter, Qnil);
+  rb_hash_clear(stmt_cache);
+  RB_GC_GUARD(stmt_cache);
+}
+
 static void Database_free(void *ptr) {
   Database_t *db = ptr;
-  if (db->sqlite3_db) sqlite3_close_v2(db->sqlite3_db);
+  if (db->sqlite3_db) {
+    stmt_cache_clear(db->sqlite3_db, db->stmt_cache);
+    sqlite3_close_v2(db->sqlite3_db);
+  }
   free(ptr);
 }
 
@@ -83,6 +105,7 @@ static const rb_data_type_t Database_type = {
 static VALUE Database_allocate(VALUE klass) {
   Database_t *db = ALLOC(Database_t);
   db->sqlite3_db = NULL;
+  db->stmt_cache = Qnil;
   db->trace_proc = Qnil;
   db->progress_handler.proc = Qnil;
   db->progress_handler.mode = PROGRESS_NONE;
@@ -127,12 +150,17 @@ default_flags:
 }
 
 void Database_apply_opts(VALUE self, Database_t *db, VALUE opts) {
+  db->flags = DB_F_STMT_CACHE;
   if (NIL_P(opts)) goto modern_pragmas;
 
   // :gvl_release_threshold
   VALUE value = rb_hash_aref(opts, SYM_gvl_release_threshold);
   if (!NIL_P(value)) db->gvl_release_threshold = NUM2INT(value);
 
+  value = rb_hash_aref(opts, SYM_stmt_cache);
+  if (value == Qfalse)
+    db->flags &= !DB_F_STMT_CACHE;
+
   value = rb_hash_aref(opts, SYM_legacy);
   if (RTEST(value)) return;
 
@@ -175,9 +203,9 @@ int Database_busy_handler(void *ptr, int v) {
  *   `#gvl_release_threshold=`).
  * - `:read_only` (`true`/`false`): opens the database in read-only mode if true.
  * - `:legacy` (`true`/`false`): By default the database is set up for
- * concurrent access with [WAL journaling
- * mode](https://www.sqlite.org/wal.html). To prevent Extralite from setting up
- * WAL journaling, set this option to true.
+ *   concurrent access with [WAL journaling mode](https://www.sqlite.org/wal.html).
+ *   To prevent Extralite from setting up WAL journaling, set this option to true.
+ * - `:stmt_cache`: true by default, set to false to disable stmt caching
  *
  * @overload initialize(path)
  *   @param path [String] file path (or ':memory:' for memory database)
@@ -215,6 +243,7 @@ VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
   sqlite3_db_config(db->sqlite3_db ,SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL);
 #endif
 
+  db->stmt_cache = rb_hash_new();
   db->trace_proc = Qnil;
   db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
 
@@ -250,6 +279,7 @@ VALUE Database_close(VALUE self) {
   int rc;
   Database_t *db = self_to_database(self);
 
+  stmt_cache_clear(db->sqlite3_db, db->stmt_cache);
   rc = sqlite3_close_v2(db->sqlite3_db);
   if (rc) {
     rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
@@ -277,12 +307,13 @@ inline enum gvl_mode Database_prepare_gvl_mode(Database_t *db) {
 
 static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VALUE (*call)(query_ctx *), enum query_mode query_mode) {
   Database_t *db = self_to_open_database(self);
-  sqlite3_stmt *stmt;
+  sqlite3_stmt *stmt = NULL;
   VALUE sql = Qnil;
   VALUE transform = Qnil;
   // transform mode is set and the first parameter is not a string, so we expect
   // a transform.,
   int got_transform = (TYPE(argv[0]) != T_STRING);
+  int execute_mode = query_mode == QUERY_VOID;
 
   // extract query from args
   rb_check_arity(argc, got_transform ? 2 : 1, UNLIMITED_ARGUMENTS);
@@ -293,26 +324,38 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
     argv++;
   }
 
-  sql = rb_funcall(argv[0], ID_strip, 0);
-  if (RSTRING_LEN(sql) == 0) return Qnil;
-  // sql = argv[0];
-
-  prepare_multi_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
-  RB_GC_GUARD(sql);
+  sql = argv[0];
 
-  if (stmt == NULL) return Qnil;
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, argc - 1, argv + 1);
 
-  bind_all_parameters(stmt, argc - 1, argv + 1);
   Database_pre_query_hook(db, stmt, sql, argc - 1, argv + 1);
-
-  query_ctx ctx = QUERY_CTX(
-    self, sql, db, stmt, Qnil, transform,
-    query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
-  );
-
-  VALUE result = rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
-  RB_GC_GUARD(result);
-  return result;
+  if (execute_mode) {
+    exec_multi_stmt(&stmt_ctx);
+
+    query_ctx ctx = QUERY_CTX(
+      self, sql, db, NULL, Qnil, transform,
+      query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
+    );
+    ctx.flags = stmt_ctx.flags;
+    ctx.total_changes = stmt_ctx.total_changes;
+    VALUE result = (VALUE)call(&ctx);
+    return result;
+  }
+  else {
+    prep_single_stmt(&stmt_ctx);
+    query_ctx ctx = QUERY_CTX(
+      self, sql, db, stmt, Qnil, transform,
+      query_mode, ROW_YIELD_OR_MODE(ROW_MULTI), ALL_ROWS
+    );
+    ctx.flags = stmt_ctx.flags;
+    if (!stmt) return Qnil;
+
+    bind_all_parameters(stmt, argc - 1, argv + 1);
+    VALUE result = rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+    RB_GC_GUARD(result);
+    return result;
+  }
 }
 
 /* call-seq:
@@ -490,7 +533,9 @@ VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
  *   db.execute(sql, *parameters) -> changes
  *
  * Runs a query returning the total changes effected. This method should be used
- * for data- or schema-manipulation queries.
+ * for data- or schema-manipulation queries. If the given SQL string contains
+ * multiple statements, they will be executed in the order given. If multiple
+ * statements are given along with query parameters, an error is raised.
  *
  * Query parameters to be bound to placeholders in the query can be specified as
  * a list of values or as a hash mapping parameter names to values. When
@@ -506,10 +551,10 @@ VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
  *
  * @param sql [String] query SQL
  * @param parameters [Array, Hash] parameters to run query with
- * @return [Integer, nil] Total number of changes effected or `nil` if the query ends with a comment.
+ * @return [Integer] Total number of changes effected
  */
 VALUE Database_execute(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_changes, QUERY_HASH);
+  return Database_perform_query(argc, argv, self, safe_total_changes, QUERY_VOID);
 }
 
 /* call-seq:
@@ -546,11 +591,15 @@ VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
 
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, 1, NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_HASH, ROW_MULTI, ALL_ROWS
   );
+  ctx.flags = stmt_ctx.flags;
 
   return rb_ensure(SAFE(safe_batch_execute), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
@@ -582,7 +631,10 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_HASH, ROW_MULTI, ALL_ROWS
@@ -616,7 +668,10 @@ VALUE Database_batch_query_array(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_ARRAY, ROW_MULTI, ALL_ROWS
@@ -650,7 +705,10 @@ VALUE Database_batch_query_splat(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
-  prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, db, &stmt, sql, RARRAY_LEN(parameters), NULL);
+  prep_single_stmt(&stmt_ctx);
+  // prepare_xsingle_stmt(DB_GVL_MODE(db), db->stmt_cache, db->sqlite3_db, &stmt, sql, 0, NULL);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
     Qnil, QUERY_SPLAT, ROW_MULTI, ALL_ROWS
@@ -1383,7 +1441,6 @@ VALUE Extralite_on_progress(int argc, VALUE *argv, VALUE self) {
  */
 VALUE Database_errcode(VALUE self) {
   Database_t *db = self_to_open_database(self);
-
   return INT2NUM(sqlite3_errcode(db->sqlite3_db));
 }
 
@@ -1393,10 +1450,19 @@ VALUE Database_errcode(VALUE self) {
  */
 VALUE Database_errmsg(VALUE self) {
   Database_t *db = self_to_open_database(self);
-
   return rb_str_new2(sqlite3_errmsg(db->sqlite3_db));
 }
 
+/* Returns the stmt cache for the database. If the database was setup with
+ * stmt_cache set to false, returns nil.
+ *
+ * @return [Hash, nil] stmt cache or nil if disabled
+ */
+VALUE Database_stmt_cache(VALUE self) {
+  Database_t *db = self_to_open_database(self);
+  return (db->flags & DB_F_STMT_CACHE) ? db->stmt_cache : Qnil;
+}
+
 #ifdef HAVE_SQLITE3_ERROR_OFFSET
 /* Returns the offset for the last error. This is useful for indicating where in
  * the SQL string an error was encountered.
@@ -1581,6 +1647,7 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "columns",                Database_columns, 1);
   rb_define_method(cDatabase, "errcode",                Database_errcode, 0);
   rb_define_method(cDatabase, "errmsg",                 Database_errmsg, 0);
+  rb_define_method(cDatabase, "stmt_cache",             Database_stmt_cache, 0);
 
   #ifdef HAVE_SQLITE3_ERROR_OFFSET
   rb_define_method(cDatabase, "error_offset",           Database_error_offset, 0);
@@ -1644,6 +1711,8 @@ void Init_ExtraliteDatabase(void) {
   ID_to_s         = rb_intern_const("to_s");
   ID_track        = rb_intern_const("track");
 
+  ID_inspect  = rb_intern_const("inspect");
+
   SYM_at_least_once         = ID2SYM(rb_intern_const("at_least_once"));
   SYM_full                  = ID2SYM(rb_intern_const("full"));
   SYM_gvl_release_threshold = ID2SYM(rb_intern_const("gvl_release_threshold"));
@@ -1654,6 +1723,7 @@ void Init_ExtraliteDatabase(void) {
   SYM_passive               = ID2SYM(rb_intern_const("passive"));
   SYM_read_only             = ID2SYM(rb_intern_const("read_only"));
   SYM_restart               = ID2SYM(rb_intern_const("restart"));
+  SYM_stmt_cache            = ID2SYM(rb_intern_const("stmt_cache"));
   SYM_truncate              = ID2SYM(rb_intern_const("truncate"));
   SYM_wal                   = ID2SYM(rb_intern_const("wal"));
 
@@ -1667,6 +1737,7 @@ void Init_ExtraliteDatabase(void) {
   rb_gc_register_mark_object(SYM_passive);
   rb_gc_register_mark_object(SYM_read_only);
   rb_gc_register_mark_object(SYM_restart);
+  rb_gc_register_mark_object(SYM_stmt_cache);
   rb_gc_register_mark_object(SYM_truncate);
   rb_gc_register_mark_object(SYM_wal);
 

data/ext/extralite/extralite.h

@@ -31,6 +31,8 @@ extern VALUE cChangeset;
 extern VALUE cBlob;
 extern VALUE cTransform;
 
+extern ID ID_inspect;
+
 extern VALUE mJSON;
 
 extern VALUE cError;
@@ -68,9 +70,13 @@ struct progress_handler {
   int                         call_count;
 };
 
+#define DB_F_STMT_CACHE (1L << 0) // cache stmts
+
 typedef struct {
   sqlite3                 *sqlite3_db;
+  VALUE                   stmt_cache;
   VALUE                   trace_proc;
+  int                     flags;
   int                     gvl_release_threshold;
   struct progress_handler progress_handler;
 } Database_t;
@@ -78,7 +84,8 @@ typedef struct {
 enum query_mode {
   QUERY_HASH,
   QUERY_SPLAT,
-  QUERY_ARRAY
+  QUERY_ARRAY,
+  QUERY_VOID
 };
 
 typedef struct {
@@ -108,7 +115,6 @@ typedef struct {
 } Changeset_t;
 #endif
 
-// #define TRANSFORM_F_CONTAINER (1 << 0) // node is a container
 #define TRANSFORM_F_ARRAY     (1 << 0) // node is an array container
 #define TRANSFORM_F_IDENTITY  (1 << 1) // node is an identity column
 #define TRANSFORM_F_NAME      (1 << 2) // node has a name VALUE
@@ -159,6 +165,7 @@ typedef struct {
   Database_t          *db;
   sqlite3             *sqlite3_db;
   sqlite3_stmt        *stmt;
+  unsigned int        flags;
 
   int                 gvl_release_threshold;
   enum query_mode     query_mode;
@@ -167,6 +174,7 @@ typedef struct {
 
   int                 eof;
   int                 step_count;
+  int                 total_changes;
 } query_ctx;
 
 enum gvl_mode {
@@ -174,24 +182,36 @@ enum gvl_mode {
   GVL_HOLD
 };
 
+#define STMT_CTX_F_USE_CACHE (1L << 0)
+#define STMT_CTX_F_CACHE_HIT (1L << 1)
+
+typedef struct {
+  VALUE stmt_cache;
+  VALUE sql;
+
+  sqlite3 *db;
+  sqlite3_stmt **stmtptr;
+
+  const char *str;
+  size_t len;
+
+  enum gvl_mode gvl_mode;
+  unsigned int flags;
+  int rc;
+  int total_changes;
+  int argc;
+  VALUE *argv;
+} stmt_ctx;
+
 #define ALL_ROWS -1
 #define SINGLE_ROW -2
 #define ROW_YIELD_OR_MODE(default) (rb_block_given_p() ? ROW_YIELD : default)
 #define ROW_MULTI_P(mode) (mode == ROW_MULTI)
 #define QUERY_CTX(self, sql, db, stmt, params, transform, query_mode, row_mode, max_rows) { \
-  self, \
-  sql, \
-  params, \
-  transform, \
-  db, \
-  db->sqlite3_db, \
-  stmt, \
-  db->gvl_release_threshold, \
-  query_mode, \
-  row_mode, \
-  max_rows, \
-  0, \
-  0 \
+  self, sql, params, transform, \
+  db, db->sqlite3_db, stmt, 0, \
+  db->gvl_release_threshold, query_mode, row_mode, max_rows, \
+  0, 0, 0  \
 }
 
 #define DEFAULT_GVL_RELEASE_THRESHOLD 1000
@@ -209,6 +229,7 @@ VALUE safe_batch_query_array(query_ctx *ctx);
 VALUE safe_query_splat(query_ctx *ctx);
 VALUE safe_query_array(query_ctx *ctx);
 VALUE safe_query_changes(query_ctx *ctx);
+VALUE safe_total_changes(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);
 VALUE safe_query_hash(query_ctx *ctx);
 VALUE safe_query_transform(query_ctx *ctx);
@@ -222,8 +243,9 @@ VALUE Query_next(int argc, VALUE *argv, VALUE self);
 VALUE Query_to_a(VALUE self);
 VALUE Query_transform_set(VALUE self, VALUE transform);
 
-void prepare_single_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
-void prepare_multi_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
+void make_stmt_ctx(stmt_ctx *ctx, Database_t *db, sqlite3_stmt **stmt, VALUE sql, int argc, VALUE *argv);
+void prep_single_stmt(stmt_ctx *ctx);
+int exec_multi_stmt(stmt_ctx *ctx);
 void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv);
 void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj);
 int stmt_iterate(query_ctx *ctx);

data/ext/extralite/iterator.c

@@ -25,7 +25,7 @@ static void Iterator_compact(void *ptr) {
 
 static const rb_data_type_t Iterator_type = {
     "Iterator",
-    {Iterator_mark, free, Iterator_size, Iterator_compact},
+    {Iterator_mark, xfree, Iterator_size, Iterator_compact},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 

data/ext/extralite/query.c

@@ -11,7 +11,6 @@
 
 VALUE cQuery;
 
-ID ID_inspect;
 ID ID_slice;
 
 VALUE SYM_hash;
@@ -132,9 +131,15 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql, VALUE mode) {
   return Qnil;
 }
 
+static inline void prep_query(Query_t *query) {
+  stmt_ctx stmt_ctx;
+  make_stmt_ctx(&stmt_ctx, query->db_struct, &(query->stmt), query->sql, 0, NULL);
+  prep_single_stmt(&stmt_ctx);
+}
+
 static inline void query_reset(Query_t *query) {
   if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+    prep_query(query);
   else
     sqlite3_reset(query->stmt);
 
@@ -146,7 +151,7 @@ static inline void query_reset(Query_t *query) {
 
 static inline void query_bind(Query_t *query, int argc, VALUE * argv) {
   if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+    prep_query(query);
   else
     // we call sqlite3_reset because that's what the SQLite API expects before
     // changing the binding. See note at bottom of
@@ -406,8 +411,7 @@ VALUE Query_batch_execute(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query_verify(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
-  if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  if (!query->stmt) prep_query(query);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -455,8 +459,7 @@ VALUE Query_batch_query(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query_verify(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
-  if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  if (!query->stmt) prep_query(query);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -562,9 +565,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
   rb_scan_args(argc, argv, "11", &op, &reset);
 
   Query_t *query = self_to_query_verify(self);
-
-  if (!query->stmt)
-    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  if (!query->stmt) prep_query(query);
 
   int value = sqlite3_stmt_status(query->stmt, NUM2INT(op), RTEST(reset) ? 1 : 0);
   return INT2NUM(value);
@@ -685,7 +686,6 @@ void Init_ExtraliteQuery(void) {
   rb_define_method(cQuery, "transform",      Query_transform_get, 0);
   rb_define_method(cQuery, "transform=",     Query_transform_set, 1);
 
-  ID_inspect  = rb_intern_const("inspect");
   ID_slice    = rb_intern_const("slice");
 
   SYM_hash    = ID2SYM(rb_intern_const("hash"));