Class: Groonga::Table

Inherits:
Object
  • Object
show all
Includes:
Enumerable, Flushable
Defined in:
ext/groonga/rb-grn-table.c,
lib/groonga/table.rb,
lib/groonga/pagination.rb,
ext/groonga/rb-grn-table.c

Overview

Rroongaが提供するテーブルのベースとなるクラス。このクラス から Array , Hash , PatriciaTrie が継承されている。

Direct Known Subclasses

Array, DoubleArrayTrie, Hash, PatriciaTrie

Defined Under Namespace

Modules: KeySupport

Instance Method Summary collapse

Methods included from Flushable

#flush

Methods inherited from Object

#==, #[]=, #accessor?, #append, #builtin?, #close, #closed?, #column?, #dirty?, #domain, #function_procedure?, #id, #index_column?, #key_accessor?, #last_modified, #name, #path, #persistent?, #prepend, #procedure?, #range, #reference_column?, #remove, #scorer_procedure?, #selector_only_procedure?, #selector_procedure?, #table?, #temporary?, #touch, #unlink, #window_function_procedure?

Constructor Details

#initializeObject



137
138
139
140
141
142
# File 'ext/groonga/rb-grn-table.c', line 137

static VALUE
rb_grn_table_initialize (VALUE self)
{
    rb_raise(rb_eArgError, "Use Groonga::Context#[] for get existing table.");
    return Qnil;
}

Instance Method Details

#[](id) ⇒ Groonga::Record

tableid に対応する Record を返す。

0.9.0から値ではなく Record を返すようになった。

Returns:



1623
1624
1625
1626
1627
1628
1629
1630
1631
# File 'ext/groonga/rb-grn-table.c', line 1623

VALUE
rb_grn_table_array_reference (VALUE self, VALUE rb_id)
{
    if (FIXNUM_P(rb_id)) {
        return rb_grn_record_new_raw(self, rb_id, Qnil);
    } else {
        return Qnil;
    }
}

#clear_lockvoid

Forces to clear lock of the table.

This method returns an undefined value.



2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
# File 'ext/groonga/rb-grn-table.c', line 2133

static VALUE
rb_grn_table_clear_lock (VALUE self)
{
    grn_ctx *context;
    grn_obj *table;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    grn_obj_clear_lock(context, table);

    return Qnil;
}

#column(name) ⇒ Groonga::Column?

テーブルの name に対応するカラムを返す。カラムが存在しな い場合は +nil+ を返す。

Returns:



523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
# File 'ext/groonga/rb-grn-table.c', line 523

VALUE
rb_grn_table_get_column (VALUE self, VALUE rb_name)
{
    grn_user_data *user_data;
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *column;
    const char *name = NULL;
    unsigned name_size = 0;
    grn_bool owner;
    VALUE rb_column;
    VALUE columns;
    VALUE *raw_columns;
    long i, n;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             &columns);

    ruby_object_to_column_name(rb_name, &name, &name_size);
    raw_columns = RARRAY_PTR(columns);
    n = RARRAY_LEN(columns);
    for (i = 0; i < n; i++) {
        VALUE rb_column = raw_columns[i];
        RbGrnNamedObject *rb_grn_named_object;

        rb_grn_named_object = RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column));
        if (name_size == rb_grn_named_object->name_size &&
            memcmp(name, rb_grn_named_object->name, name_size) == 0) {
            return rb_column;
        }
    }

    column = grn_obj_column(context, table, name, name_size);
    rb_grn_context_check(context, self);
    if (!column)
        return Qnil;

    user_data = grn_obj_user_data(context, column);
    if (user_data) {
        RbGrnObject *rb_grn_object;
        rb_grn_object = user_data->ptr;
        if (rb_grn_object) {
            rb_ary_push(columns, rb_grn_object->self);
            return rb_grn_object->self;
        }
    }

    owner = column->header.type == GRN_ACCESSOR;
    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, owner);
    if (owner) {
        rb_grn_context_register_floating_object(DATA_PTR(rb_column));
    }
    rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
                                 name, name_size);

    return rb_column;
}

#column_value(id, name) ⇒ #column_value(id, name, : id=>true) ⇒

tableid に対応するカラム name の値を返す。

@:id => true@ が指定できるのは利便性のため。 Array でも HashPatriciaTrie と 同じ引数で動くようになる。

Overloads:

  • #column_value(id, name) ⇒

    Returns:

    • ()
  • #column_value(id, name, : id=>true) ⇒

    Returns:

    • ()


1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
# File 'ext/groonga/rb-grn-table.c', line 1784

static VALUE
rb_grn_table_get_column_value_convenience (int argc, VALUE *argv, VALUE self)
{
    VALUE rb_id, rb_name, rb_options;

    rb_scan_args(argc, argv, "21", &rb_id, &rb_name, &rb_options);
    if (!NIL_P(rb_options)) {
        VALUE rb_option_id;
        rb_grn_scan_options(rb_options,
                            "id", &rb_option_id,
                            NULL);
        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
            VALUE rb_related_object;
            rb_related_object =
                rb_ary_new_from_args(2,
                                     self,
                                     rb_ary_new_from_values(argc, argv));
            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
                     rb_grn_inspect(rb_option_id),
                     rb_grn_inspect(rb_related_object));
        }
    }

    return rb_grn_table_get_column_value(self, rb_id, rb_name);
}

#columns(name = nil) ⇒ Groonga::Columnの配列

テーブルの全てのカラムを返す。 name が指定された場合はカ ラム名の先頭が name で始まるカラムを返す。

Returns:



604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
# File 'ext/groonga/rb-grn-table.c', line 604

static VALUE
rb_grn_table_get_columns (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *columns;
    grn_obj *key_type;
    grn_rc rc;
    int n;
    grn_table_cursor *cursor;
    VALUE rb_name, rb_columns;
    char *name = NULL;
    unsigned name_size = 0;
    VALUE exception;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_scan_args(argc, argv, "01", &rb_name);

    if (!NIL_P(rb_name)) {
        name = StringValuePtr(rb_name);
        name_size = RSTRING_LEN(rb_name);
    }

    key_type = grn_ctx_at(context, GRN_DB_SHORT_TEXT);
    columns = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_HASH_KEY,
                               key_type, 0);
    rb_grn_context_check(context, self);
    n = grn_table_columns(context, table, name, name_size, columns);
    rb_grn_context_check(context, self);

    rb_columns = rb_ary_new2(n);
    if (n == 0) {
        grn_obj_unlink(context, columns);
        return rb_columns;
    }

    cursor = grn_table_cursor_open(context, columns, NULL, 0, NULL, 0,
                                   0, -1, GRN_CURSOR_ASCENDING);
    rb_grn_context_check(context, self);
    while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
        void *key;
        grn_id *column_id;
        grn_obj *column;
        VALUE rb_column;
        grn_user_data *user_data;
        grn_bool need_to_set_name = GRN_FALSE;

        grn_table_cursor_get_key(context, cursor, &key);
        column_id = key;
        column = grn_ctx_at(context, *column_id);
        exception = rb_grn_context_to_exception(context, self);
        if (!NIL_P(exception)) {
            grn_table_cursor_close(context, cursor);
            grn_obj_unlink(context, columns);
            rb_exc_raise(exception);
        }

        user_data = grn_obj_user_data(context, column);
        if (user_data && !user_data->ptr) {
            need_to_set_name = GRN_TRUE;
        }
        rb_column = GRNOBJECT2RVAL(Qnil, context, column, GRN_FALSE);
        if (need_to_set_name) {
            char name[GRN_TABLE_MAX_KEY_SIZE];
            int name_size = 0;
            RbGrnNamedObject *rb_grn_named_object;
            name_size = grn_column_name(context, column,
                                        name, GRN_TABLE_MAX_KEY_SIZE);
            rb_grn_named_object = RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column));
            rb_grn_named_object_set_name(rb_grn_named_object, name, name_size);
        }

        rb_ary_push(rb_columns, rb_column);
    }
    rc = grn_table_cursor_close(context, cursor);
    grn_obj_unlink(context, columns);
    if (rc != GRN_SUCCESS) {
        rb_grn_context_check(context, self);
        rb_grn_rc_check(rc, self);
    }

    return rb_columns;
}

#define_column(name, value_type, options = {}) ⇒ Groonga::FixSizeColumn, Groonga::VariableSizeColumn

テーブルに名前が name で型が value_type のカラムを定義 し、新しく定義されたカラムを返す。

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :path (Object)

    カラムを保存するパス。

  • :persistent (Object) — default: 永続カラム

    +true+ を指定すると永続カラムとなる。省略した場合は永 続カラムとなる。 +:path+ を省略した場合は自動的にパスが 付加される。

  • :type (Object) — default: :scalar

    カラムの値の格納方法について指定する。省略した場合は、 +:scalar+ になる。

    • +:scalar+ := スカラ値(単独の値)を格納する。
    • +:vector+ := 値の配列を格納する。
  • :with_weight (Boolean) — default: false

    It specifies whether making the column weight vector column or not. Weight vector column can store weight for each element.

    You can’t use this option for scalar column.

  • :compress (Object)

    値の圧縮方法を指定する。省略した場合は、圧縮しない。

    • :zlib: Compressed by zlib.
    • :lz4: Compressed by LZ4.
    • :zstd: Compressed by Zstandard.
    • :zstandard: Compressed by Zstandard.

Returns:



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
# File 'ext/groonga/rb-grn-table.c', line 239

static VALUE
rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *value_type, *column;
    char *name = NULL, *path = NULL;
    unsigned name_size = 0;
    grn_column_flags flags = 0;
    VALUE rb_name, rb_value_type;
    VALUE options, rb_path, rb_persistent, rb_compress, rb_type, rb_with_weight;
    VALUE columns;
    VALUE rb_column;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             &columns);

    rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);

    name = StringValuePtr(rb_name);
    name_size = RSTRING_LEN(rb_name);

    rb_grn_scan_options(options,
                        "path", &rb_path,
                        "persistent", &rb_persistent,
                        "type", &rb_type,
                        "with_weight", &rb_with_weight,
                        "compress", &rb_compress,
                        NULL);

    value_type = RVAL2GRNOBJECT(rb_value_type, &context);

    if ((NIL_P(rb_persistent) && grn_obj_path(context, table)) ||
        RVAL2CBOOL(rb_persistent)) {
        flags |= GRN_OBJ_PERSISTENT;
    }

    if (!NIL_P(rb_path)) {
        path = StringValueCStr(rb_path);
        if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
            rb_raise(rb_eArgError,
                     "should not pass :path if :persistent is false: <%s>",
                     path);
        }
        flags |= GRN_OBJ_PERSISTENT;
    }

    if (NIL_P(rb_type) ||
        (rb_grn_equal_option(rb_type, "scalar"))) {
        flags |= GRN_OBJ_COLUMN_SCALAR;
    } else if (rb_grn_equal_option(rb_type, "vector")) {
        flags |= GRN_OBJ_COLUMN_VECTOR;
    } else {
        rb_raise(rb_eArgError,
                 "invalid column type: %s: "
                 "available types: [:scalar, :vector, nil]",
                 rb_grn_inspect(rb_type));
    }

    if (RVAL2CBOOL(rb_with_weight)) {
        if (flags & GRN_OBJ_COLUMN_VECTOR) {
            flags |= GRN_OBJ_WITH_WEIGHT;
        } else {
            rb_raise(rb_eArgError,
                     "can't use weight for scalar column");
        }
    }

    if (NIL_P(rb_compress)) {
    } else if (rb_grn_equal_option(rb_compress, "zlib")) {
        flags |= GRN_OBJ_COMPRESS_ZLIB;
    } else if (rb_grn_equal_option(rb_compress, "lzo")) {
        /* TODO: for backward compatibility */
        flags |= GRN_OBJ_COMPRESS_LZ4;
    } else if (rb_grn_equal_option(rb_compress, "lz4")) {
        flags |= GRN_OBJ_COMPRESS_LZ4;
    } else if (rb_grn_equal_option(rb_compress, "zstd")) {
        flags |= GRN_OBJ_COMPRESS_ZSTD;
    } else if (rb_grn_equal_option(rb_compress, "zstandard")) {
        flags |= GRN_OBJ_COMPRESS_ZSTD;
    } else {
        rb_raise(rb_eArgError,
                 "invalid compress type: %s: "
                 "available types: [:zlib, :lz4, :zstd, :zstandard, nil]",
                 rb_grn_inspect(rb_compress));
    }

    column = grn_column_create(context, table, name, name_size,
                               path, flags, value_type);
    if (context->rc) {
        VALUE rb_related_object;
        rb_related_object =
            rb_ary_new_from_args(2,
                                 self,
                                 rb_ary_new_from_values(argc, argv));
        rb_grn_context_check(context, rb_related_object);
    }

    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, GRN_TRUE);
    rb_ary_push(columns, rb_column);
    rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
                                 name, name_size);

    return rb_column;
}

#define_index_column(name, value_type, options = {}) ⇒ Groonga::IndexColumn

テーブルに名前が name で型が value_type のインデックスカ ラムを定義し、新しく定義されたカラムを返す。

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :path (Object)

    カラムを保存するパス。

  • :persistent (Object) — default: 永続カラム

    +true+ を指定すると永続カラムとなる。省略した場合は永 続カラムとなる。 +:path+ を省略した場合は自動的にパスが 付加される。

  • :with_section (Object)

    転置索引にsection(段落情報)を合わせて格納する。

  • :with_weight (Object)

    転置索引にweight情報を合わせて格納する。

  • :with_position (Object)

    転置索引に出現位置情報を合わせて格納する。

  • :size (Object) — default: nil

    The size of index column. It must be nil, :small or :medium. nil means full size. :small means small size. :medium means medium size.

  • :source (Object)

    インデックス対象となるカラムを指定する。 +:sources+ との併用はできない。

  • :sources (Object)

    インデックス対象となる複数のカラムを指定する。 +:source+ との併用はできない。

Returns:



377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
# File 'ext/groonga/rb-grn-table.c', line 377

static VALUE
rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *value_type, *column;
    char *name = NULL, *path = NULL;
    unsigned name_size = 0;
    grn_column_flags flags = GRN_OBJ_COLUMN_INDEX;
    VALUE rb_name, rb_value_type;
    VALUE options, rb_path, rb_persistent;
    VALUE rb_with_section, rb_with_weight, rb_with_position;
    VALUE rb_size;
    VALUE rb_column, rb_source, rb_sources;
    VALUE columns;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             &columns);

    rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);

    name = StringValuePtr(rb_name);
    name_size = RSTRING_LEN(rb_name);

    rb_grn_scan_options(options,
                        "path", &rb_path,
                        "persistent", &rb_persistent,
                        "with_section", &rb_with_section,
                        "with_weight", &rb_with_weight,
                        "with_position", &rb_with_position,
                        "size", &rb_size,
                        "source", &rb_source,
                        "sources", &rb_sources,
                        NULL);

    value_type = RVAL2GRNOBJECT(rb_value_type, &context);

    if ((NIL_P(rb_persistent) && grn_obj_path(context, table)) ||
        RVAL2CBOOL(rb_persistent)) {
        flags |= GRN_OBJ_PERSISTENT;
    }

    if (!NIL_P(rb_path)) {
        path = StringValueCStr(rb_path);
        if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
            rb_raise(rb_eArgError,
                     "should not pass :path if :persistent is false: <%s>",
                     path);
        }
        flags |= GRN_OBJ_PERSISTENT;
    }

    if (NIL_P(rb_with_section)) {
        if (TYPE(rb_sources) == T_ARRAY && RARRAY_LEN(rb_sources) > 1) {
            flags |= GRN_OBJ_WITH_SECTION;
        }
    } else if (RVAL2CBOOL(rb_with_section)) {
        flags |= GRN_OBJ_WITH_SECTION;
    }


    if (RVAL2CBOOL(rb_with_weight))
        flags |= GRN_OBJ_WITH_WEIGHT;

    if (NIL_P(rb_with_position) &&
        (table->header.type == GRN_TABLE_HASH_KEY ||
         table->header.type == GRN_TABLE_PAT_KEY)) {
        grn_obj *tokenizer;

        tokenizer = grn_obj_get_info(context, table,
                                     GRN_INFO_DEFAULT_TOKENIZER,
                                     NULL);
        if (tokenizer) {
            rb_with_position = Qtrue;
        }
    }
    if (RVAL2CBOOL(rb_with_position))
        flags |= GRN_OBJ_WITH_POSITION;

    if (NIL_P(rb_size)) {
        /* do nothing */
    } else if (rb_grn_equal_option(rb_size, "small")) {
        flags |= GRN_OBJ_INDEX_SMALL;
    } else if (rb_grn_equal_option(rb_size, "medium")) {
        flags |= GRN_OBJ_INDEX_MEDIUM;
    } else {
        rb_raise(rb_eArgError,
                 ":size must be nil, :small or :medium: <%" PRIsVALUE ">",
                 rb_size);
    }

    if (!NIL_P(rb_source) && !NIL_P(rb_sources))
        rb_raise(rb_eArgError, "should not pass both of :source and :sources.");

    column = grn_column_create(context, table, name, name_size,
                               path, flags, value_type);
    if (context->rc) {
        VALUE rb_related_object;
        rb_related_object =
            rb_ary_new_from_args(2, self, rb_ary_new_from_values(argc, argv));
        rb_grn_context_check(context, rb_related_object);
    }

    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, GRN_TRUE);
    if (!NIL_P(rb_source))
        rb_funcall(rb_column, rb_intern("source="), 1, rb_source);
    if (!NIL_P(rb_sources))
        rb_funcall(rb_column, rb_intern("sources="), 1, rb_sources);

    rb_ary_push(columns, rb_column);
    rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
                                 name, name_size);

    return rb_column;
}

#defrag(options = {}) ⇒ Integer

Defrags all variable size columns in the table.

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :threshold (Integer) — default: 0

    the threshold to determine whether a segment is defraged. Available values are -4..22. -4 means all segments are defraged. 22 means no segment is defraged.

Returns:

  • (Integer)

    the number of defraged segments

Since:

  • 1.3.0



2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
# File 'ext/groonga/rb-grn-table.c', line 2591

static VALUE
rb_grn_table_defrag (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context;
    grn_obj *table;
    int n_segments;
    VALUE options, rb_threshold;
    int threshold = 0;

    rb_scan_args(argc, argv, "01", &options);
    rb_grn_scan_options(options,
                        "threshold", &rb_threshold,
                        NULL);
    if (!NIL_P(rb_threshold)) {
        threshold = NUM2INT(rb_threshold);
    }

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL, NULL,
                             NULL, NULL,
                             NULL);
    n_segments = grn_obj_defrag(context, table, threshold);
    rb_grn_context_check(context, self);

    return INT2NUM(n_segments);
}

#delete(id) ⇒ Object #delete {|record| ... } ⇒ Object

Overloads:

  • #delete(id) ⇒ Object

    Delete a record that has ID @id@.

    Parameters:

    • id (Integer)

      The ID of delete target record.

    Returns:

    • void

  • #delete {|record| ... } ⇒ Object

    Delete records that are matched with the given condition specified block.

    Examples:

    Delete users that are younger than 20.

    users.delete do |recod|
      record.age < 20
    end

    Yields:

    • (record)

      TODO: See #select.

    Yield Parameters:

    • record (Groonga::RecodExpressionBuilder)

      TODO: See #select.

    Yield Returns:

    • (Groonga::ExpressionBuilder)

      TODO: See #select.

    Returns:

    • void



1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
# File 'ext/groonga/rb-grn-table.c', line 1135

static VALUE
rb_grn_table_delete (int argc, VALUE *argv, VALUE self)
{
    VALUE rb_id;

    rb_scan_args(argc, argv, "01", &rb_id);

    if (rb_block_given_p()) {
        rb_grn_table_delete_by_expression(self);
    } else {
        rb_grn_table_delete_by_id(self, rb_id);
    }

    return Qnil;
}

#difference!(other) ⇒ Groonga::Table

キーを比較し、 other にも登録されているレコードを table から削除する。

Returns:



2451
2452
2453
2454
2455
# File 'ext/groonga/rb-grn-table.c', line 2451

static VALUE
rb_grn_table_difference_bang (VALUE self, VALUE rb_other)
{
    return rb_grn_table_set_operation_bang(self, rb_other, GRN_OP_AND_NOT);
}

#disk_usageObject



20
21
22
23
# File 'lib/groonga/table.rb', line 20

def disk_usage
  measurer = StatisticMeasurer.new
  measurer.measure_disk_usage(path)
end

#each {|record| ... } ⇒ nil #each(options = {}) {|record| ... } ⇒ nil

テーブルに登録されているレコードを順番にブロックに渡す。

options is the same as #open_cursor ‘s one.

Overloads:

  • #each {|record| ... } ⇒ nil

    Yields:

    • (record)

    Returns:

    • (nil)
  • #each(options = {}) {|record| ... } ⇒ nil

    Yields:

    • (record)

    Returns:

    • (nil)


1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
# File 'ext/groonga/rb-grn-table.c', line 1020

static VALUE
rb_grn_table_each (int argc, VALUE *argv, VALUE self)
{
    EachData data;

    RETURN_ENUMERATOR(self, argc, argv);

    data.cursor = rb_grn_table_open_grn_cursor(argc, argv, self,
                                               &(data.context));
    if (!data.cursor) {
        return Qnil;
    }

    data.self = self;
    rb_ensure(rb_grn_table_each_body, (VALUE)&data,
              rb_grn_table_each_ensure, (VALUE)&data);

    return Qnil;
}

#each_sub_record(id) {|sub_record| ... } ⇒ void

Iterates each sub records for the record id.

This method returns an undefined value.

Yields:

  • (sub_record)

    Gives a sub record for the record id to the block.

Yield Parameters:

  • sub_record (Record)

    A sub record for the record id.

Since:

  • 3.0.3



1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
# File 'ext/groonga/rb-grn-table.c', line 1586

static VALUE
rb_grn_table_each_sub_record (VALUE self, VALUE rb_id)
{
    VALUE rb_range;
    grn_obj *table, *range;
    grn_ctx *context = NULL;
    grn_id *sub_records_buffer;
    unsigned int i, n_sub_records, max_n_sub_records;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, &range,
                             NULL);
    max_n_sub_records = grn_table_max_n_subrecs(context, table);
    if (max_n_sub_records == 0) {
        return Qnil;
    }
    RETURN_ENUMERATOR(self, 0, NULL);
    sub_records_buffer = ALLOCA_N(grn_id, max_n_sub_records);
    n_sub_records = grn_table_get_subrecs(context, table, NUM2UINT(rb_id),
                                          sub_records_buffer, NULL,
                                          (int)max_n_sub_records);
    rb_range = GRNOBJECT2RVAL(Qnil, context, range, GRN_FALSE);
    for (i = 0; i < n_sub_records; i++) {
        rb_yield(rb_grn_record_new(rb_range, sub_records_buffer[i], Qnil));
    }
    return Qnil;
}

#empty?Boolean

テーブルにレコードが登録されていなければ +true+ を返す。

Returns:

  • (Boolean)


926
927
928
929
930
931
932
933
934
935
936
937
938
939
# File 'ext/groonga/rb-grn-table.c', line 926

static VALUE
rb_grn_table_empty_p (VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    unsigned int size;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    size = grn_table_size(context, table);
    return CBOOL2RVAL(size == 0);
}

#exist?(id) ⇒ Boolean

tableid で指定したIDのレコードが存在する場合は +true+ 、 存在しない場合は +false+ を返す。

注意: 実行には相応のコストがかかるのであまり頻繁に呼ばな いようにして下さい。

Returns:

  • (Boolean)


2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
# File 'ext/groonga/rb-grn-table.c', line 2565

static VALUE
rb_grn_table_exist_p (VALUE self, VALUE id)
{
    grn_ctx *context;
    grn_obj *table;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    return CBOOL2RVAL(grn_table_at(context, table, NUM2UINT(id)));
}

#geo_sort(column, base_geo_point, options = {}) ⇒ Groonga::Array

Sorts records in the table by TokyoGeoPoint or WGS84GeoPoint type column value. Order is near to far from base geo point.

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :offset (Object) — default: 0

    It specifies what number record should be the first record in returned table. It’s 0-based.

    If you specify 0, the 0th record, the 1st record, the 2nd record, … are returned.

    If you specify 0, the 1st record, the 2nd record, … are returned. The 0th record isn’t returned.

    The default is 0.

  • :limit (Object) — default: -1

    It specifies up to how many records are returned. If -1 is specified, all records are returned.

    The default is -1.

Returns:

  • (Groonga::Array)

    The sorted result. You can get the original record by #value method of a record in the sorted result. Normally, you doesn’t need to get the original record because you can access via column name method:

    If you want to access the key of the original record, you need to get the original record.

Since:

  • 5.0.9



1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
# File 'ext/groonga/rb-grn-table.c', line 1325

static VALUE
rb_grn_table_geo_sort (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    VALUE rb_column;
    VALUE rb_base_geo_point;
    VALUE rb_options;
    VALUE rb_offset;
    VALUE rb_limit;
    grn_obj *column;
    grn_id column_range_id;
    grn_obj base_geo_point;
    int offset = 0;
    int limit = -1;
    grn_obj *result;
    VALUE exception;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_scan_args(argc, argv, "21", &rb_column, &rb_base_geo_point, &rb_options);

    column = RVAL2GRNOBJECT(rb_column, &context);
    column_range_id = grn_obj_get_range(context, column);
    switch (column_range_id) {
    case GRN_DB_TOKYO_GEO_POINT:
        GRN_TOKYO_GEO_POINT_INIT(&base_geo_point, 0);
        break;
    case GRN_DB_WGS84_GEO_POINT:
        GRN_WGS84_GEO_POINT_INIT(&base_geo_point, 0);
        break;
    default:
        rb_raise(rb_eArgError,
                 "column's range must be TokyoGeoPoint or WGS84GeoPoint: %s",
                 rb_grn_inspect(rb_column));
        break;
    }
    RVAL2GRNBULK_WITH_TYPE(rb_base_geo_point,
                           context,
                           &base_geo_point,
                           column_range_id,
                           grn_ctx_at(context, column_range_id));

    rb_grn_scan_options(rb_options,
                        "offset", &rb_offset,
                        "limit", &rb_limit,
                        NULL);

    if (!NIL_P(rb_offset))
        offset = NUM2INT(rb_offset);
    if (!NIL_P(rb_limit))
        limit = NUM2INT(rb_limit);

    result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
                              NULL, table);
    grn_geo_table_sort(context, table, offset, limit,
                       result, column, &base_geo_point);
    exception = rb_grn_context_to_exception(context, self);
    if (!NIL_P(exception)) {
        grn_obj_unlink(context, &base_geo_point);
        grn_obj_unlink(context, result);
        rb_exc_raise(exception);
    }

    grn_obj_unlink(context, &base_geo_point);
    return GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
}

#group([key1, key2, ...], options = {}) ⇒ Groonga::Hash #group(key, options = {}) ⇒ Groonga::Hash

table のレコードを key1 , key2 , で指定したキーの 値でグループ化する。多くの場合、キーにはカラムを指定する。 カラムはカラム名(文字列)でも指定可能。

If one key is specified, you can get the grouping key by Record#key:

grouped_records = table.group("key1").collect do |group|
  [group.key, group.n_sub_records]
end

If two or more keys are specified, the default value of :max_n_sub_records is 1 (When one key is specified, the value is 0.). You can get the grouping keys by Record#sub_records:

grouped_records = table.group(["key1", "key2"]).collect do |group|
  sub_record = group.sub_records.first
  [
    sub_record.key1,
    sub_record.key2,
    group.n_sub_records,
  ]
end

Overloads:

  • #group([key1, key2, ...], options = {}) ⇒ Groonga::Hash

    Options Hash (options):

    • :max_n_sub_records (Object)

      グループ化した後のレコードのそれぞれについて最大:max_n_sub_records件まで そのグループに含まれる table のレコードをサブレコードとして格納する。

    • :calc_target (String, Symbol)

      The target column name for :calc_types.

    • :calc_types (::Array)

      It specifies how to calculate (aggregate) values in grouped records by a drilldown. You can specify multiple calculation types.

      • +:max+ := Finding the maximum integer value from integer values in grouped records.
      • +:min+ := Finding the minimum integer value from integer values in grouped records.
      • +:sum+ := Summing integer values in grouped records.
      • +:average+ := Averaging integer/float values in grouped records.

    Returns:

  • #group(key, options = {}) ⇒ Groonga::Hash

    Options Hash (options):

    • :max_n_sub_records (Object)

      グループ化した後のレコードのそれぞれについて最大:max_n_sub_records件まで そのグループに含まれる table のレコードをサブレコードとして格納する。

    • :calc_target (String, Symbol)

      The target column name for :calc_types.

    • :calc_types (::Array)

      It specifies how to calculate (aggregate) values in grouped records by a drilldown. You can specify multiple calculation types.

      • +:max+ := Finding the maximum integer value from integer values in grouped records.
      • +:min+ := Finding the minimum integer value from integer values in grouped records.
      • +:sum+ := Summing integer values in grouped records.
      • +:average+ := Averaging integer/float values in grouped records.

    Returns:



1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
# File 'ext/groonga/rb-grn-table.c', line 1451

static VALUE
rb_grn_table_group (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_table_sort_key *keys;
    grn_table_group_result result;
    int i, n_keys;
    unsigned int max_n_sub_records = 0;
    grn_rc rc;
    VALUE rb_keys, rb_options, rb_max_n_sub_records;
    VALUE rb_calc_target, rb_calc_types;
    VALUE *rb_group_keys;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_scan_args(argc, argv, "11", &rb_keys, &rb_options);

    if (TYPE(rb_keys) == T_ARRAY) {
        n_keys = RARRAY_LEN(rb_keys);
        rb_group_keys = RARRAY_PTR(rb_keys);
    } else {
        n_keys = 1;
        rb_group_keys = &rb_keys;
    }

    rb_grn_scan_options(rb_options,
                        "max_n_sub_records", &rb_max_n_sub_records,
                        "calc_target", &rb_calc_target,
                        "calc_types", &rb_calc_types,
                        NULL);

    if (NIL_P(rb_max_n_sub_records)) {
        if (n_keys > 1) {
            max_n_sub_records = 1;
        } else {
            max_n_sub_records = 0;
        }
    } else {
        max_n_sub_records = NUM2UINT(rb_max_n_sub_records);
    }

    keys = ALLOCA_N(grn_table_sort_key, n_keys);
    for (i = 0; i < n_keys; i++) {
        VALUE rb_sort_options, rb_key;

        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_group_keys[i], rb_cHash))) {
            rb_sort_options = rb_group_keys[i];
        } else {
            rb_sort_options = rb_hash_new();
            rb_hash_aset(rb_sort_options,
                         RB_GRN_INTERN("key"),
                         rb_group_keys[i]);
        }
        rb_grn_scan_options(rb_sort_options,
                            "key", &rb_key,
                            NULL);
        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
            VALUE resolved_rb_key;
            resolved_rb_key = rb_grn_table_get_column(self, rb_key);
            if (NIL_P(resolved_rb_key)) {
                rb_raise(rb_eArgError,
                         "unknown group key: <%s>: <%s>",
                         rb_grn_inspect(rb_key),
                         rb_grn_inspect(self));
            }
            rb_key = resolved_rb_key;
        }
        keys[i].key = RVAL2GRNOBJECT(rb_key, &context);
        keys[i].flags = 0;
    }

    result.table = NULL;
    result.key_begin = 0;
    result.key_end = n_keys - 1;
    result.limit = 1;
    result.flags = GRN_TABLE_GROUP_CALC_COUNT;
    result.op = GRN_OP_OR;
    result.max_n_subrecs = max_n_sub_records;
    result.calc_target = NULL;

    if (!NIL_P(rb_calc_target)) {
        const char *name = NULL;
        unsigned name_size = 0;
        ruby_object_to_column_name(rb_calc_target, &name, &name_size);
        result.calc_target = grn_obj_column(context, table, name, name_size);
    }
    if (result.calc_target) {
        int i, n_calc_types;
        VALUE *raw_calc_types;
        raw_calc_types = RARRAY_PTR(rb_calc_types);
        n_calc_types = RARRAY_LEN(rb_calc_types);
        for (i = 0; i < n_calc_types; i++) {
            VALUE rb_calc_type = raw_calc_types[i];
            if (rb_grn_equal_option(rb_calc_type, "max")) {
                result.flags |= GRN_TABLE_GROUP_CALC_MAX;
            } else if (rb_grn_equal_option(rb_calc_type, "min")) {
                result.flags |= GRN_TABLE_GROUP_CALC_MIN;
            } else if (rb_grn_equal_option(rb_calc_type, "sum")) {
                result.flags |= GRN_TABLE_GROUP_CALC_SUM;
            } else if (rb_grn_equal_option(rb_calc_type, "average")) {
                result.flags |= GRN_TABLE_GROUP_CALC_AVG;
            } else {
                grn_obj_unlink(context, result.calc_target);
                rb_raise(rb_eArgError,
                         "invalid calculation type: %s: "
                         "available types: [:max, :min, :sum, :average]",
                         rb_grn_inspect(rb_calc_type));
            }
        }
    }

    rc = grn_table_group(context, table, keys, n_keys, &result, 1);
    if (result.calc_target) {
        grn_obj_unlink(context, result.calc_target);
    }
    rb_grn_context_check(context, self);
    rb_grn_rc_check(rc, self);

    return GRNOBJECT2RVAL(Qnil, context, result.table, GRN_TRUE);
}

#have_column?(name) ⇒ Boolean

テーブルが name カラムを持っている場合は +true+ を返す。

Returns:

  • (Boolean)


697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
# File 'ext/groonga/rb-grn-table.c', line 697

static VALUE
rb_grn_table_have_column (VALUE self, VALUE rb_name)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *column;
    const char *name = NULL;
    unsigned name_size = 0;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    ruby_object_to_column_name(rb_name, &name, &name_size);
    column = grn_obj_column(context, table, name, name_size);
    if (column) {
        grn_obj_unlink(context, column);
        return Qtrue;
    } else {
        return Qfalse;
    }
}

#have_n_sub_records_space?Boolean

#group returns a table that contains grouped records. If grouped table has a space to store the number of records for each group, the number of records is stored to it. Records for each group are called as “sub records”.

Normally, you don’t need to care about the space because Rroonga creates a table with the space automatically. Normal tables (persistent tables) don’t have the space because they don’t need it.

Examples:

A normal table don’t have the space

users = Groonga["Users"] # A normal table
users.have_n_sub_records_space? # => false

A grouped table has the space

users = Groonga["Users"]                # A normal table
grouped_users = users.group("_key")     # A grouped table
grouped_users.have_n_sub_records_space? # => true

Returns:

  • (Boolean)

    @true@ if the table has a space for storing the number of sub records, @false@ otherwise.

  • (Boolean)


2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
# File 'ext/groonga/rb-grn-table.c', line 2544

static VALUE
rb_grn_table_have_n_sub_records_space_p (VALUE self)
{
    grn_obj *table;

    rb_grn_table_deconstruct(SELF(self), &table, NULL,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    return CBOOL2RVAL(table->header.flags & GRN_OBJ_WITH_SUBREC);
}

#inspectString

テーブルの中身を人に見やすい文字列で返す。

Returns:

  • (String)


191
192
193
194
195
196
197
198
199
200
201
202
203
# File 'ext/groonga/rb-grn-table.c', line 191

static VALUE
rb_grn_table_inspect (VALUE self)
{
    VALUE inspected;

    inspected = rb_str_new_cstr("");
    rb_grn_object_inspect_header(self, inspected);
    rb_grn_object_inspect_content(self, inspected);
    rb_grn_table_inspect_content(self, inspected);
    rb_grn_object_inspect_footer(self, inspected);

    return inspected;
}

#intersection!(other) ⇒ Groonga::Table

キーを比較し、 other には登録されていないレコードを table から削除する。

Returns:



2438
2439
2440
2441
2442
# File 'ext/groonga/rb-grn-table.c', line 2438

static VALUE
rb_grn_table_intersection_bang (VALUE self, VALUE rb_other)
{
    return rb_grn_table_set_operation_bang(self, rb_other, GRN_OP_AND);
}

#lock(options = {}) ⇒ Object #lock(options = {}) { ... } ⇒ Object

table をロックする。ロックに失敗した場合は ResourceDeadlockAvoided 例外が発生する。

ブロックを指定した場合はブロックを抜けたときにunlockする。

Overloads:

  • #lock(options = {}) ⇒ Object

    Parameters:

    • options (::Hash) (defaults to: {})

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :timeout (Object)

      ロックを獲得できなかった場合は :timeout 秒間ロックの獲 得を試みる。 :timeout 秒以内にロックを獲得できなかった 場合は例外が発生する。

    • :id (Object)

      :id で指定したレコードをロックする。(注: groonga側が 未実装のため、現在は無視される)

  • #lock(options = {}) { ... } ⇒ Object

    Parameters:

    • options (::Hash) (defaults to: {})

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :timeout (Object)

      ロックを獲得できなかった場合は :timeout 秒間ロックの獲 得を試みる。 :timeout 秒以内にロックを獲得できなかった 場合は例外が発生する。

    • :id (Object)

      :id で指定したレコードをロックする。(注: groonga側が 未実装のため、現在は無視される)

    Yields:

    • ブロックを抜けたときにunlockする。



2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
# File 'ext/groonga/rb-grn-table.c', line 2088

static VALUE
rb_grn_table_lock (int argc, VALUE *argv, VALUE self)
{
    grn_id id = GRN_ID_NIL;
    grn_ctx *context;
    grn_obj *table;
    int timeout = 0;
    grn_rc rc;
    VALUE options, rb_timeout, rb_id;

    rb_scan_args(argc, argv, "01",  &options);

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_grn_scan_options(options,
                        "timeout", &rb_timeout,
                        "id", &rb_id,
                        NULL);

    if (!NIL_P(rb_timeout))
        timeout = NUM2UINT(rb_timeout);

    if (!NIL_P(rb_id))
        id = NUM2UINT(rb_id);

    rc = grn_obj_lock(context, table, id, timeout);
    rb_grn_context_check(context, self);
    rb_grn_rc_check(rc, self);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, Qnil, rb_grn_table_unlock_ensure, self);
    } else {
        return Qnil;
    }
}

#locked?Boolean

Checks whether the table is locked or not.

Returns true if the table is locked, false otherwise.

Returns:

  • (Boolean)

    true if the table is locked, false otherwise.

Returns:

  • (Boolean)


2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
# File 'ext/groonga/rb-grn-table.c', line 2155

static VALUE
rb_grn_table_locked_p (VALUE self)
{
    grn_ctx *context;
    grn_obj *table;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    return CBOOL2RVAL(grn_obj_is_locked(context, table));
}

#merge!(other) ⇒ Groonga::Table

キーを比較し、 other にも登録されている table のレコード のスコアを other のスコアと同値にする。

Returns:



2464
2465
2466
2467
2468
# File 'ext/groonga/rb-grn-table.c', line 2464

static VALUE
rb_grn_table_merge_bang (VALUE self, VALUE rb_other)
{
    return rb_grn_table_set_operation_bang(self, rb_other, GRN_OP_ADJUST);
}

#open_cursor(options = {}) ⇒ Groonga::TableCursor #open_cursor(options = {}) {|cursor| ... } ⇒ Object

カーソルを生成して返す。ブロックを指定すると、そのブロッ クに生成したカーソルが渡され、ブロックを抜けると自動的に カーソルが破棄される。

Overloads:

  • #open_cursor(options = {}) ⇒ Groonga::TableCursor

    Parameters:

    • options (::Hash) (defaults to: {})

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :min (Object)

      キーの下限

    • :max (Object)

      キーの上限

    • :offset (Object)

      該当する範囲のレコードのうち、(0ベースで) :offset 番目 からレコードを取り出す。

    • :limit (Object)

      該当する範囲のレコードのうち、 :limit 件のみを取り出す。 省略された場合または-1が指定された場合は、全件が指定され たものとみなす。

    • :order (Object) — default: asc

      +:asc+ または +:ascending+ を指定すると昇順にレコードを取 り出す。(デフォルト) +:desc+ または +:descending+ を指定すると降順にレコードを 取り出す。

    • :order_by (Object)

      +:id+ を指定するとID順にレコードを取り出す。(Arrayと Hashのデフォルト) +:key+ 指定するとキー順にレコードを取り出す。ただし、 Groonga::PatriciaTrieにしか使えない。(PatriciaTrieのデ フォルト)

    • :greater_than (Object)

      +true+ を指定すると +:min+ で指定した値に一致した [ +key+ ] を 範囲に含まない。

    • :less_than (Object)

      +true+ を指定すると +:max+ で指定した値に一致した [ +key+ ] を 範囲に含まない。

    Returns:

  • #open_cursor(options = {}) {|cursor| ... } ⇒ Object

    Parameters:

    • options (::Hash) (defaults to: {})

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :min (Object)

      キーの下限

    • :max (Object)

      キーの上限

    • :offset (Object)

      該当する範囲のレコードのうち、(0ベースで) :offset 番目 からレコードを取り出す。

    • :limit (Object)

      該当する範囲のレコードのうち、 :limit 件のみを取り出す。 省略された場合または-1が指定された場合は、全件が指定され たものとみなす。

    • :order (Object) — default: asc

      +:asc+ または +:ascending+ を指定すると昇順にレコードを取 り出す。(デフォルト) +:desc+ または +:descending+ を指定すると降順にレコードを 取り出す。

    • :order_by (Object)

      :id means that the cursor returns the next record by ID order. It’s the default for Groonga::Array and Groonga::Hash.

      :key means that the cursor returns the next record by key order. You can use it only for Groonga::PatriciaTrie and Groonga::DoubleArrayTrie. It’s the default for Groonga::PatriciaTrie and Groonga::DoubleArrayTrie.

    • :greater_than (Object)

      +true+ を指定すると +:min+ で指定した値に一致した [ +key+ ] を 範囲に含まない。

    • :less_than (Object)

      +true+ を指定すると +:max+ で指定した値に一致した [ +key+ ] を 範囲に含まない。

    Yields:

    • (cursor)


859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
# File 'ext/groonga/rb-grn-table.c', line 859

static VALUE
rb_grn_table_open_cursor (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_table_cursor *cursor;
    VALUE rb_cursor;

    cursor = rb_grn_table_open_grn_cursor(argc, argv, self, &context);
    rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
    rb_iv_set(rb_cursor, "@table", self); /* FIXME: cursor should mark table */
    if (rb_block_given_p())
        return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
    else
        return rb_cursor;
}

#paginate(sort_keys, options = {}) ⇒ Object

ページネーション用便利メソッド。ページネーションをした い場合は #sort よりも #paginate の方が便利。

説明文(descriptionカラム)を「Ruby」で全文検索し、 検索結果をスコアの高い順にソートして、10項目ずつ表示する 場合は以下のようになる。

query = "Ruby"
entries = Groonga["entries"]
selected_entries = entries.select do |record|
  entry.description =~ query
end
paged_entries = selected_entries.paginate([["_score", :desc]],
                                          :page => 1,
                                          :size => 10)

#sort と違い、返される Groonga::Table オブジェクトには Pagination モジュールがextendされており、 以下のようにページネーション情報を取得できる。

puts "#{paged_entries.n_records}件ヒット"
puts "#{paged_entries.start_offset}-#{paged_entries.end_offset}件を表示"
paged_entries.each do |entry|
  puts entry.description
end

sort_keys には ソートに用いる情報を指定する。 指定の仕方は #sort と同様なので、詳細は #sort を参照。

options に指定可能な値は以下の通り。

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :size (Integer) — default: 10

    1ページあたりに表示する最大項目数。

  • :page (Integer) — default: 1

    ページ番号。ページ番号は0ベースではなく1ベースであることに注意。



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
# File 'lib/groonga/pagination.rb', line 114

def paginate(sort_keys, options={})
  _size = size
  page_size = options[:size] || 10
  minimum_size = [1, _size].min
  if page_size < 1
    raise TooSmallPageSize.new(page_size, minimum_size.._size)
  end

  max_page = [(_size / page_size.to_f).ceil, 1].max
  page = options[:page] || 1
  if page < 1
    raise TooSmallPage.new(page, 1..max_page)
  elsif max_page < page
    raise TooLargePage.new(page, 1..max_page)
  end

  offset = (page - 1) * page_size
  limit = page_size
  records = sort(sort_keys, :offset => offset, :limit => limit)
  records.extend(Pagination)
  records.send(:set_pagination_info, page, page_size, _size)
  records
end

#recordsGroonga::Recordの配列

テーブルに登録されている全てのレコードが入っている配列を 返す。

Returns:



882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
# File 'ext/groonga/rb-grn-table.c', line 882

static VALUE
rb_grn_table_get_records (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_table_cursor *cursor;
    grn_id record_id;
    VALUE records;

    cursor = rb_grn_table_open_grn_cursor(argc, argv, self, &context);
    records = rb_ary_new();
    while ((record_id = grn_table_cursor_next(context, cursor))) {
        rb_ary_push(records, rb_grn_record_new(self, record_id, Qnil));
    }
    grn_table_cursor_close(context, cursor);

    return records;
}

#rename(name) ⇒ Object

Renames the table to name.

Parameters:

  • name (String)

    the new name

Since:

  • 1.3.0



2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
# File 'ext/groonga/rb-grn-table.c', line 2625

static VALUE
rb_grn_table_rename (VALUE self, VALUE rb_name)
{
    int rc;
    grn_ctx *context;
    grn_obj *table;
    char *name;
    int name_size;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL, NULL,
                             NULL, NULL,
                             NULL);

    name = StringValueCStr(rb_name);
    name_size = RSTRING_LEN(rb_name);

    rc = grn_table_rename(context, table, name, name_size);
    rb_grn_context_check(context, self);
    rb_grn_rc_check(rc, self);

    return self;
}

#select(options) {|record| ... } ⇒ Groonga::Hash #select(query, options) ⇒ Groonga::Hash #select(expression, options) ⇒ Groonga::Hash

table からブロックまたは文字列で指定した条件にマッチする レコードを返す。返されたテーブルには +expression+ という特 異メソッドがあり、指定した条件を表している Expression を取得できる。 Expression#snippet を使うことにより、指定した条件 用のスニペットを簡単に生成できる。

results = table.select do |record|
  record["description"] =~ "groonga"
end
snippet = results.expression.snippet([["<em>", "</em>"]])
results.each do |record|
  puts "#{record['name']}の説明文の中で「groonga」が含まれる部分"
  snippet.execute(record["description"]).each do |snippet|
    puts "---"
    puts "#{snippet}..."
    puts "---"
  end
end

出力例

rroongaの説明文の中で「groonga」が含まれる部分
---
rroongaは<em>groonga</em>のいわゆるDB-APIの層の...
---

Overloads:

  • #select(options) {|record| ... } ⇒ Groonga::Hash

    Yields:

    • (record)

      ブロックで条件を指定する場合は Groonga::RecordExpressionBuilderを参照。

      Ruby1.9以降では、ブロックで条件を指定する際に Groonga::ColumnExpressionBuilderの他に”!=”も使用可能。

      例:

      comments = Groonga::Array.create(:name => "Comments")
      comments.define_column("content", "Text")
      comments.add(:content => "Hello Good-bye!")
      comments.add(:content => "Hello World")
      comments.add(:content => "test")
      result = comments.select do |record|
        record.content != "test"
      end
      p result.collect {|record| record.content}
        # => ["Hello Good-bye!", "Hello World"]
      
  • #select(query, options) ⇒ Groonga::Hash

    query には「[カラム名]:[演算子][値]」という書式で条件を 指定する。演算子は以下の通り。

    • なし := [カラム値] == [値]
    • @!@ := [カラム値] != [値]
    • @<@ := [カラム値] < [値]
    • @>@ := [カラム値] > [値]
    • @<=@ := [カラム値] <= [値]
    • @>=@ := [カラム値] >= [値]
    • @@@ := [カラム値]が[値]を含んでいるかどうか

    例:

    "name:daijiro" # "name"カラムの値が"daijiro"のレコードにマッチ
    "description:@groonga" # "description"カラムが
                           # "groonga"を含んでいるレコードにマッチ
    

    参考: Expression#parse .

    Parameters:

    • options (::Hash)

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :default_column (Object)

      “column_name:hoge”ではなく”hoge”のようにcolumn_nameが指 定されない条件の検索対象となるカラムを指定する。

    • :operator (Object) — default: Groonga::Operator::OR

      マッチしたレコードをどのように扱うか。指定可能な値は以 下の通り。省略した場合はGroonga::Operator::OR。

      • Groonga::Operator::OR := マッチしたレコードを追加。すでにレコードが追加されている場合 は何もしない。 =:
      • Groonga::Operator::AND := マッチしたレコードのスコアを増加。マッチしなかったレコードを削除。 =:
      • Groonga::Operator::AND_NOT := マッチしたレコードを削除。 =:
      • Groonga::Operator::ADJUST := マッチしたレコードのスコアを増加。 =:
    • :result (Object)

      検索結果を格納するテーブル。マッチしたレコードが追加さ れていく。省略した場合は新しくテーブルを作成して返す。

    • :name (Object)

      条件の名前。省略した場合は名前を付けない。

    • :syntax (Object)

      query の構文。省略した場合は +:query+ 。

      参考: Expression#parse .

    • :allow_pragma (Object)

      query構文時にプラグマを利用するかどうか。省略した場合は 利用する。

      参考: Expression#parse .

    • :allow_column (Object)

      query構文時にカラム指定を利用するかどうか。省略した場合 は利用する。

      参考: Expression#parse .

    • :allow_update (Object)

      script構文時に更新操作を利用するかどうか。省略した場合 は利用する。

  • #select(expression, options) ⇒ Groonga::Hash

    expression には既に作成済みの Expression を渡す。

    参考: Expression#parse .

    Parameters:

    • options (::Hash)

      The name and value pairs. Omitted names are initialized as the default value.

    Options Hash (options):

    • :default_column (Object)

      “column_name:hoge”ではなく”hoge”のようにcolumn_nameが指 定されない条件の検索対象となるカラムを指定する。

    • :operator (Object) — default: Groonga::Operator::OR

      マッチしたレコードをどのように扱うか。指定可能な値は以 下の通り。省略した場合はGroonga::Operator::OR。

      • Groonga::Operator::OR := マッチしたレコードを追加。すでにレコードが追加されている場合 は何もしない。 =:
      • Groonga::Operator::AND := マッチしたレコードのスコアを増加。マッチしなかったレコードを削除。 =:
      • Groonga::Operator::AND_NOT := マッチしたレコードを削除。 =:
      • Groonga::Operator::ADJUST := マッチしたレコードのスコアを増加。 =:
    • :result (Object)

      検索結果を格納するテーブル。マッチしたレコードが追加さ れていく。省略した場合は新しくテーブルを作成して返す。

    • :name (Object)

      条件の名前。省略した場合は名前を付けない。

    • :syntax (Object)

      query の構文。省略した場合は +:query+ 。

      参考: Expression#parse .

    • :allow_pragma (Object)

      query構文時にプラグマを利用するかどうか。省略した場合は 利用する。

      参考: Expression#parse .

    • :allow_column (Object)

      query構文時にカラム指定を利用するかどうか。省略した場合 は利用する。

      参考: Expression#parse .

    • :allow_update (Object)

      script構文時に更新操作を利用するかどうか。省略した場合 は利用する。

Returns:



2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
# File 'ext/groonga/rb-grn-table.c', line 2302

static VALUE
rb_grn_table_select (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context;
    grn_obj *table, *result, *expression;
    grn_operator operator = GRN_OP_OR;
    VALUE rb_query = Qnil, condition_or_options, options;
    VALUE rb_name, rb_operator, rb_result, rb_syntax;
    VALUE rb_allow_pragma, rb_allow_column, rb_allow_update, rb_allow_leading_not;
    VALUE rb_default_column;
    VALUE rb_expression = Qnil, builder;

    rb_scan_args(argc, argv, "02", &condition_or_options, &options);

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options, rb_cString))) {
        rb_query = condition_or_options;
    } else if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options,
                                            rb_cGrnExpression))) {
        rb_expression = condition_or_options;
    } else {
        if (!NIL_P(options))
            rb_raise(rb_eArgError,
                     "should be [query_string, option_hash], "
                     "[expression, option_hash] "
                     "or [option_hash]: %s",
                     rb_grn_inspect(rb_ary_new_from_values(argc, argv)));
        options = condition_or_options;
    }

    rb_grn_scan_options(options,
                        "operator", &rb_operator,
                        "result", &rb_result,
                        "name", &rb_name,
                        "syntax", &rb_syntax,
                        "allow_pragma", &rb_allow_pragma,
                        "allow_column", &rb_allow_column,
                        "allow_update", &rb_allow_update,
                        "allow_leading_not", &rb_allow_leading_not,
                        "default_column", &rb_default_column,
                        NULL);

    if (!NIL_P(rb_operator))
        operator = NUM2INT(rb_operator);

    if (NIL_P(rb_result)) {
        result = grn_table_create(context, NULL, 0, NULL,
                                  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
                                  table,
                                  NULL);
        rb_grn_context_check(context, self);
        if (!result) {
            rb_raise(rb_eGrnNoMemoryAvailable,
                     "failed to create result table: %s",
                     rb_grn_inspect(rb_ary_new_from_values(argc, argv)));
        }
        rb_result = GRNTABLE2RVAL(context, result, GRN_TRUE);
    } else {
        result = RVAL2GRNTABLE(rb_result, &context);
    }

    if (NIL_P(rb_expression)) {
      builder = rb_grn_record_expression_builder_new(self, rb_name);
      rb_funcall(builder, rb_intern("query="), 1, rb_query);
      rb_funcall(builder, rb_intern("syntax="), 1, rb_syntax);
      rb_funcall(builder, rb_intern("allow_pragma="), 1, rb_allow_pragma);
      rb_funcall(builder, rb_intern("allow_column="), 1, rb_allow_column);
      rb_funcall(builder, rb_intern("allow_update="), 1, rb_allow_update);
      rb_funcall(builder, rb_intern("allow_leading_not="), 1, rb_allow_leading_not);
      rb_funcall(builder, rb_intern("default_column="), 1, rb_default_column);
      rb_expression = rb_grn_record_expression_builder_build(builder);
    }
    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
                              &expression, NULL,
                              NULL, NULL, NULL, NULL);

    grn_table_select(context, table, expression, result, operator);
    rb_grn_context_check(context, self);

    rb_attr(rb_singleton_class(rb_result),
            rb_intern("expression"),
            GRN_TRUE, GRN_FALSE, GRN_FALSE);
    rb_iv_set(rb_result, "@expression", rb_expression);

    return rb_result;
}

#set_column_value(id, name, value) ⇒ void #set_column_value(id, name, vector_value_with_weight) ⇒ void #set_column_value(id, name, value, options) ⇒ void #set_column_value(id, name, vector_value_with_weight, options) ⇒ void

This method returns an undefined value.

Sets @value@ as the value of column @name@ of the record that has @id@ ID. It overwrites the previous value.

Overloads:

  • #set_column_value(id, name, value) ⇒ void

    Parameters:

    • id (Integer)

      The ID of the target record.

    • name (String, Symbol)

      The name of the target column.

    • value (::Object)

      The new value.

  • #set_column_value(id, name, vector_value_with_weight) ⇒ void
    Note:

    To use weight, there are two requirements. They are using vector column and using index column with weight support. Weight supported index column can be created with @:with_weight => true@ option. See #define_index_column.

    Sets the vector column value and its weight. Weight is used when fulltext search. In fulltext search, score @1@ is added when a record is matched against a query. If weight is set, score @1 + weight@ is added when a record is matched against a query.

    Examples:

    Sets vector value with weight

    Groonga::Schema.define do |schema|
      schema.create_table("Sites") do |table|
        table.short_text("name")
        table.short_text("tags", :type => :vector) # It must be vector
      end
    
      schema.create_table("Tags",
                          :type     => :patricia_trie,
                          :key_type => :short_text) do |table|
        table.index("Sites.tags",
                    :with_weight => true) # Don't forget :with_weight => true!
      end
    end
    
    sites = Groonga["Sites"]
    
    groonga_org_id = sites.add.id
    sites.set_column_value(groonga_org_id,
                           "name",
                           "groonga.org")
    sites.set_column_value(groonga_org_id,
                           "tags",
                           [
                             # 10 weight is set
                             {
                               :value => "groonga",
                               :weight => 10,
                             },
                             # No :weight. The default weight is used.
                             {
                               :value => "search engine",
                             },
                             # Value only. The default weight is used.
                             "fulltext search",
                           ])
    
    # "groonga" tag has 10 weight.
    records = sites.select do |record|
      record.tags =~ "groonga"
    end
    p records.collect(&:score) # => [11] (1 + 10 weight)
    
    # "search engine" tag has the default weight. (0 weight)
    records = sites.select do |record|
      record.tags =~ "search engine"
    end
    p records.collect(&:score) # => [1] (1 + 0 weight)
    
    # "fulltext search" tag has the default weight. (0 weight)
    records = sites.select do |record|
      record.tags =~ "fulltext search"
    end
    p records.collect(&:score) # => [1] (1 + 0 weight)

    Parameters:

    • id (Integer)

      The ID of the target record.

    • name (String, Symbol)

      The name of the target column.

    • vector_value_with_weight

      [::Array<::Hash=> ::Object, :weight => Integer, ::Object>] The new vector value with weight. The vector value can contain both ::Hash and value. If a contained element uses ::Hash style, it can specify its weight. If a contained element doesn’t use ::Hash style, it can’t specify its weight.

      If ::Hash contains @:weight@ key, its value is used as weight for @:value@ key’s value. If ::Hash contains only @:value@ or @:weight@ value is nil, the default weight is used. The default weight is 0.

  • #set_column_value(id, name, value, options) ⇒ void

    This usage is just for convenience. #set_column_value is overrided by Groonga::Table::KeySupport#set_column_value. Groonga::Table::KeySupport#set_column_value accepts not only ID but also key value as the first argument. If you specify @:id => true@ as @options, you can use both this #set_column_value method and Groonga::Table::KeySupport#set_column_value with the same way.

    Examples:

    Uses @:id => true@ for polymorphic usage

    Groonga::Schema.define do |schema|
      schema.create_table("Sites",
                          :type     => :hash,
                          :key_type => :short_text) do |table|
        table.short_text("name")
      end
    
      schema.create_table("Logs") do |table|
        table.short_text("content")
      end
    end
    
    sites = Groonga["Sites"]
    logs = Groonga["Logs"]
    
    groonga_org_key = "http://groonga.org/"
    groonga_org_id = sites.add(groonga_org_key).id
    p sites.class # => Groonga::Hash
    # :id => true is required!
    sites.set_column_value(groonga_org_id,
                           "name",
                           "The official groonga site",
                           :id => true)
    p sites[groonga_org_key].name # => "The official groonga site"
    
    log_id = logs.add.id
    p logs.class # => Groonga::Array
    # :id => true is optional. It is just ignored.
    logs.set_column_value(log_id,
                          "content",
                          "127.0.0.1 - - [...]",
                          :id => true)
    p logs[log_id].content # => "127.0.0.1 - - [...]"

    Parameters:

    • id (Integer)

      The ID of the target record.

    • name (String, Symbol)

      The name of the target column.

    • value (::Object)

      The new value.

    • options (::Hash)

      The options

    Options Hash (options):

    • :id (Boolean)

      It is just for convenience. Specify @true@ for polymorphic usage.

  • #set_column_value(id, name, vector_value_with_weight, options) ⇒ void

    It is weight supported vector value variable of @:id => true@ option. See other signature for usage.

    Parameters:

    • id (Integer)

      The ID of the target record.

    • name (String, Symbol)

      The name of the target column.

    • vector_value_with_weight

      [::Array<::Hash=> ::Object, :weight => Integer, ::Object>] The new vector value with weight. The vector value can contain both ::Hash and value. If a contained element uses ::Hash style, it can specify its weight. If a contained element doesn’t use ::Hash style, it can’t specify its weight.

      If ::Hash contains @:weight@ key, its value is used as weight for @:value@ key’s value. If ::Hash contains only @:value@ or @:weight@ value is nil, the default weight is used. The default weight is 0.

    • options (::Hash)

      The options

    Options Hash (options):

    • :id (Boolean)

      It is just for convenience. Specify @true@ for polymorphic usage.



1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
# File 'ext/groonga/rb-grn-table.c', line 1988

static VALUE
rb_grn_table_set_column_value_convenience (int argc, VALUE *argv, VALUE self)
{
    VALUE rb_id, rb_name, rb_value, rb_options;

    rb_scan_args(argc, argv, "31", &rb_id, &rb_name, &rb_value, &rb_options);
    if (!NIL_P(rb_options)) {
        VALUE rb_option_id;
        rb_grn_scan_options(rb_options,
                            "id", &rb_option_id,
                            NULL);
        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
            VALUE rb_related_object;
            rb_related_object =
                rb_ary_new_from_args(2,
                                     self,
                                     rb_ary_new_from_values(argc, argv));
            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
                     rb_grn_inspect(rb_option_id),
                     rb_grn_inspect(rb_related_object));
        }
    }

    return rb_grn_table_set_column_value(self, rb_id, rb_name, rb_value);
}

#set_value(id, value) ⇒ Object #set_value(id, value, : id=>true) ⇒ Object

tableid に対応する値として value 設定する。既存の値は 上書きされる。

@:id => true@ が指定できるのは利便性のため。 Array でも HashPatriciaTrie と 同じ引数で動くようになる。



1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
# File 'ext/groonga/rb-grn-table.c', line 1729

static VALUE
rb_grn_table_set_value_convenience (int argc, VALUE *argv, VALUE self)
{
    VALUE rb_id, rb_value, rb_options;

    rb_scan_args(argc, argv, "21", &rb_id, &rb_value, &rb_options);
    if (!NIL_P(rb_options)) {
        VALUE rb_option_id;
        rb_grn_scan_options(rb_options,
                            "id", &rb_option_id,
                            NULL);
        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
            VALUE rb_related_object;
            rb_related_object =
                rb_ary_new_from_args(2,
                                     self,
                                     rb_ary_new_from_values(argc, argv));
            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
                     rb_grn_inspect(rb_option_id),
                     rb_grn_inspect(rb_related_object));
        }
    }

    return rb_grn_table_set_value(self, rb_id, rb_value);
}

#sizeInteger

テーブルに登録されているレコード数を返す。

Returns:

  • (Integer)


906
907
908
909
910
911
912
913
914
915
916
917
918
919
# File 'ext/groonga/rb-grn-table.c', line 906

static VALUE
rb_grn_table_get_size (VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    unsigned int size;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    size = grn_table_size(context, table);
    return UINT2NUM(size);
}

#sort(keys, options = {}) ⇒ Groonga::Array

Note:

The return value is changed to Array from Array since 2.1.0. If you want to get before 2.1.0 style result, use the following code:

テーブルに登録されているレコードを keys で指定されたルー ルに従ってソートしたレコードの配列を返す。

order には +:asc+ , +:ascending+ , +:desc+ , +:descending+ の いずれを指定する。

  • ハッシュの配列で指定する方法 := オーソドックスな指定方法。
[
 {:key => "第1ソートキー", :order => order},
 {:key => "第2ソートキー", :order => order},
 # ...,
]

=:

  • 配列の配列で指定する方法 := 少し簡単化した指定方法。
[
 ["第1ソートキー", order],
 ["第2ソートキー", order],
 # ...,
]

=:

  • ソートキーの配列で指定する方法 := order は常に昇順( +:ascending+ )になるが、最も簡単 に指定できる。
["第1ソートキー", "第2ソートキー", "..."]

=:

Examples:

Describe incompatible API change

result_since_2_1_0 = table.sort(["sort_key"])
result_before_2_1_0 = result_since_2_1_0.collect do |record|
  record.value
end

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :offset (Object)

    ソートされたレコードのうち、(0ベースで) :offset 番目 からレコードを取り出す。

  • :limit (Object)

    ソートされたレコードのうち、 :limit 件のみを取り出す。 省略された場合または-1が指定された場合は、全件が指定され たものとみなす。

Returns:

  • (Groonga::Array)

    The sorted result. You can get the original record by #value method of a record in the sorted result. Normally, you doesn’t need to get the original record because you can access via column name method:

    names_recommended_access = sorted_users.collect do |sorted_user|
      sorted_user.name
    end
    names_manually_access = sorted_users.collect do |sorted_user|
      sorted_user.value.name
    end
    names_recommended_access == names_manually_access # => true
    

    If you want to access the key of the original record, you need to get the original record.



1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
# File 'ext/groonga/rb-grn-table.c', line 1234

static VALUE
rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_obj *result;
    grn_table_sort_key *keys;
    int n_keys;
    int offset = 0, limit = -1;
    VALUE rb_keys, options;
    VALUE rb_offset, rb_limit;
    VALUE exception;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_scan_args(argc, argv, "11", &rb_keys, &options);

    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_keys, rb_cArray)))
        rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
                 rb_grn_inspect(rb_keys));

    n_keys = RARRAY_LEN(rb_keys);
    keys = ALLOCA_N(grn_table_sort_key, n_keys);
    rb_grn_table_sort_keys_fill(context, keys, n_keys, rb_keys, self);

    rb_grn_scan_options(options,
                        "offset", &rb_offset,
                        "limit", &rb_limit,
                        NULL);

    if (!NIL_P(rb_offset))
        offset = NUM2INT(rb_offset);
    if (!NIL_P(rb_limit))
        limit = NUM2INT(rb_limit);

    result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
                              NULL, table);
    /* use n_records that is return value from
       grn_table_sort() when Rroonga user become specifying
       output table. */
    grn_table_sort(context, table, offset, limit, result, keys, n_keys);
    exception = rb_grn_context_to_exception(context, self);
    if (!NIL_P(exception)) {
        grn_obj_unlink(context, result);
        rb_exc_raise(exception);
    }

    return GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
}

#support_key?Boolean

table に主キーが設定されていれば +true+ 、されていなければ +false+ を返す。

Returns:

  • (Boolean)


2476
2477
2478
2479
2480
# File 'ext/groonga/rb-grn-table.c', line 2476

static VALUE
rb_grn_table_support_key_p (VALUE self)
{
    return Qfalse;
}

#support_sub_records?Boolean

グループ化したとき、テーブルにグループに含まれるレコード 数を格納できる場合は +true+ 、格納できない場合は +false+ を返 す。

Returns:

  • (Boolean)


2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
# File 'ext/groonga/rb-grn-table.c', line 2507

static VALUE
rb_grn_table_support_sub_records_p (VALUE self)
{
    grn_obj *table;
    grn_ctx *context;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    return CBOOL2RVAL(grn_table_is_grouped(context, table));
}

#support_value?Object

otherwise.

Returns:

  • @true@ if the table is created with value type, @false@

Returns:

  • (Boolean)


2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
# File 'ext/groonga/rb-grn-table.c', line 2488

static VALUE
rb_grn_table_support_value_p (VALUE self)
{
    grn_id range_id;

    rb_grn_table_deconstruct(SELF(self), NULL, NULL,
                             NULL, NULL,
                             NULL, &range_id, NULL,
                             NULL);
    return CBOOL2RVAL(range_id != GRN_ID_NIL);
}

#truncateObject

テーブルの全レコードを一括して削除する。



946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
# File 'ext/groonga/rb-grn-table.c', line 946

static VALUE
rb_grn_table_truncate (VALUE self)
{
    grn_ctx *context = NULL;
    grn_obj *table;
    grn_rc rc;

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);
    rc = grn_table_truncate(context, table);
    rb_grn_rc_check(rc, self);

    return Qnil;
}

#union!(other) ⇒ Groonga::Table

キーを比較し、 table には登録されていない other のレコー ドを table に作成する。

Returns:



2424
2425
2426
2427
2428
# File 'ext/groonga/rb-grn-table.c', line 2424

static VALUE
rb_grn_table_union_bang (VALUE self, VALUE rb_other)
{
    return rb_grn_table_set_operation_bang(self, rb_other, GRN_OP_OR);
}

#unlock(options = {}) ⇒ Object

table のロックを解除する。

Parameters:

  • options (::Hash) (defaults to: {})

    The name and value pairs. Omitted names are initialized as the default value.

Options Hash (options):

  • :id (Object)

    :id で指定したレコードのロックを解除する。(注: groonga側が未実装のため、現在は無視される)



2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
# File 'ext/groonga/rb-grn-table.c', line 2024

static VALUE
rb_grn_table_unlock (int argc, VALUE *argv, VALUE self)
{
    grn_id id = GRN_ID_NIL;
    grn_ctx *context;
    grn_obj *table;
    grn_rc rc;
    VALUE options, rb_id;

    rb_scan_args(argc, argv, "01",  &options);

    rb_grn_table_deconstruct(SELF(self), &table, &context,
                             NULL, NULL,
                             NULL, NULL, NULL,
                             NULL);

    rb_grn_scan_options(options,
                        "id", &rb_id,
                        NULL);

    if (!NIL_P(rb_id))
        id = NUM2UINT(rb_id);

    rc = grn_obj_unlock(context, table, id);
    rb_grn_context_check(context, self);
    rb_grn_rc_check(rc, self);

    return Qnil;
}

#value(id) ⇒ #value(id, : id=>true) ⇒

tableid に対応する値を返す。

@:id => true@ が指定できるのは利便性のため。 Array でも HashPatriciaTrie と 同じ引数で動くようになる。

Overloads:

  • #value(id) ⇒

    Returns:

    • ()
  • #value(id, : id=>true) ⇒

    Returns:

    • ()


1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
# File 'ext/groonga/rb-grn-table.c', line 1667

static VALUE
rb_grn_table_get_value_convenience (int argc, VALUE *argv, VALUE self)
{
    VALUE rb_id, rb_options;

    rb_scan_args(argc, argv, "11", &rb_id, &rb_options);
    if (!NIL_P(rb_options)) {
        VALUE rb_option_id;
        rb_grn_scan_options(rb_options,
                            "id", &rb_option_id,
                            NULL);
        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
            VALUE rb_related_object;
            rb_related_object =
                rb_ary_new_from_args(2,
                                     self,
                                     rb_ary_new_from_values(argc, argv));
            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
                     rb_grn_inspect(rb_option_id),
                     rb_grn_inspect(rb_related_object));
        }
    }

    return rb_grn_table_get_value(self, rb_id);
}