#author("2017-05-29T22:06:22+09:00","default:haikikyou","haikikyou")
#author("2017-05-30T23:49:34+09:00","default:haikikyou","haikikyou")
[[PostgreSQL/開発]]

#contents

* 概要 [#o44c23aa]

- ビットマップの機能
- 要素値は非負数のみ
- ワードサイズはutint32

#ref(./bitmapset_image.png,60%)
* 定義 [#y54658dc]

** 変数,エイリアス [#xbab96df]

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
// ワードの変数名
typedef uint32 bitmapword;		/* must be an unsigned type */
// ワード(符号あり),LSB算出に使われる
typedef int32 signedbitmapword; /* must be the matching signed type */
}}}


** マクロ [#z17bcdfc]

*** BITS_PER_BITMAPWORD [#j46732f4]

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
#define BITS_PER_BITMAPWORD 32
}}}

ワードサイズ
** 列挙型 [#r016dac4]

*** BMS_Comparison [#c4e1831b]
|~定数名|~説明|h
|BMS_EQUAL|等しい|
|BMS_SUBSET1|1番目最初のセットが2番目のセットのサブセットである|
|BMS_SUBSET|2番目最初のセットが1番目のセットのサブセットである|
|BMS_DIFFERENT|異なるビットマップセットである|


- ビットマップセット同士の関連を示す列挙定数
*** BMS_Membership [#v4e5d865]

|~定数名|~説明|h
|BMS_EMPTY_SET|空のセット|
|BMS_SINGLETON|シングルトンセットか,メンバーが1つ|
|BMS_MULTIPLE|複数セット,メンバーが複数|

- ビットマップセットのメンバーシップ
- ビットマップセットのメンバーシップを示す列挙定数

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset()
{
    Bitmapset *bm = bms_make_singleton(1);
    bms_singleton_member(bm); // 1
    // 要素は1つ
    elog(NOTICE, "%d", bms_membership(bm) == BMS_SINGLETON); // NOTICE:  1
    bm = bms_add_member(bm, 2);
    // 複数の要素あり
    elog(NOTICE, "%d", bms_membership(bm) == BMS_MULTIPLE); // NOTICE:  1
    bm  = bms_del_member(bm, 1);
    bm  = bms_del_member(bm, 2);
    // 要素は空
    elog(NOTICE, "%d", bms_membership(bm) == BMS_EMPTY_SET); // NOTICE:  1
    elog(NOTICE, "%d", bms_is_empty(bm)); // NOTICE:  1
}
}}}
** 構造体 [#g3b005c3]

*** Bitmapset [#w1a2c428]

|~番号|~データ型|~フィールド|~説明|h
|1|int|nwords|wordの数|
|2|bitmapword|words[]|ビットマップ,サイズは自動拡張される|
** 関数 [#x7a379c3]

*** bms_copy [#i7fb952d]

#geshi(c){{{
// 引数1:コピー対象のビットマップセットのポインタ
// 戻り値:コピーされたビットマップセットのポインタ
extern Bitmapset *bms_copy(const Bitmapset *a);
}}}

- 指定されたビットマップセットのコピーを作成する。

*** bms_equal [#k7ca3a73]

#geshi(c){{{
// 引数1:比較する対象のビットマップセットのポインタ
// 引数2:比較する対象のビットマップセットのポインタ
// 戻り値:true:等しい,false:等しくない
extern bool bms_equal(const Bitmapset *a, const Bitmapset *b);
}}}

- 指定されたビットマップセットが等しいか比較する。
- 片方がNULLの場合,他方のbms_is_empty()の結果を返す。両方ともNULLの場合は,trueとなる。

&size(12){&color(white,orange){ 参考 };}; [[bms_equal()>https://doxygen.postgresql.org/bitmapset_8c.html#a26209f4c84c47e37eaeb94e5dcf89eca]] - on doxygen.postgresql.org
*** bms_make_singleton [#xfe5a00d]

#geshi(c){{{
// 引数1:ビットマップセットに格納する初期数値
// 戻り値:ビットマップセットのポインタ
extern Bitmapset *bms_make_singleton(int x);
}}}

- 指定された数値を登録してビットマップセットを作成する。

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
Bitmapset *bm = bms_make_singleton(1);
}}}

*** bms_free [#x8745666]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
extern void bms_free(Bitmapset *a);
}}}

- ビットマップセットの領域を解放する。

*** bms_union [#q9a01f34]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:和集合のビットマップセットのポインタ
//         aがNULLの場合,bのコピー
//         bがNULLの場合は,aのコピー
extern Bitmapset *bms_union(const Bitmapset *a, const Bitmapset *b);
}}}

- 指定されたビットマップセットの和集合を返す。
- bms_join関数と異なり,指定されたビットマップは書き換えなし。bms_copy()された結果に対して処理される。


&size(12){&color(white,orange){ 参考 };}; [[bms_union()>https://doxygen.postgresql.org/bitmapset_8h.html#a78c6db56481f05927c32a9f7fe09d14a]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_union()
{
    Bitmapset *bm1 = bms_make_singleton(0);
    bm1 = bms_add_member(bm1, 1);
    bm1 = bms_add_member(bm1, 12);

    Bitmapset *bm2 = bms_make_singleton(1);
    bm2 = bms_add_member(bm2, 3);
    bm2 = bms_add_member(bm2, 5);
    bm2 = bms_add_member(bm2, 32);

    Bitmapset *new_bm = bms_union(bm1, bm2);

    int result = -1;
    while ((result = bms_first_member(bm1)) >= 0) {
        elog(INFO, "bm1 member: %d", result);
    }

    result = -1;
    while ((result = bms_first_member(bm2)) >= 0) {
        elog(INFO, "bm2 member: %d", result);
    }

    result = -1;
    while ((result = bms_first_member(new_bm)) >= 0) {
        elog(INFO, "new_bm member: %d", result);
    }
}

/* Output is the following:
------------------------------
INFO:  bm1 member: 0
INFO:  bm1 member: 1
INFO:  bm1 member: 12
INFO:  bm2 member: 1
INFO:  bm2 member: 3
INFO:  bm2 member: 5
INFO:  bm2 member: 32
INFO:  new_bm member: 0
INFO:  new_bm member: 1
INFO:  new_bm member: 3
INFO:  new_bm member: 5
INFO:  new_bm member: 12
INFO:  new_bm member: 32
*/
}}}
*** bms_intersect [#t377e68f]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:積集合のビットマップセットのポインタ
//         aまたはbがNULLの場合,NULL
extern Bitmapset *bms_intersect(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- 指定されたビットマップの積集合を返す。
- bms_join関数と異なり,指定されたビットマップは書き換えなし。bms_copy()された結果に対して処理される。

*** bms_difference [#r00f4def]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:差集合のベースとなる対象のビットマップセットのポインタ
// 引数2:差集合を計算する対象のビットマップセットのポインタ
// 戻り値:差集合のビットマップセットのポインタ
//         aがNULLの場合,NULL
//         bがNULLの場合,aのコピー
extern Bitmapset *bms_difference(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- a - bの差集合を計算する。
- bms_join関数と異なり,指定されたビットマップは書き換えなし。bms_copy()された結果に対して処理される。

*** bms_is_subset [#eff4dc92]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:ベースとなる対象のビットマップセットのポインタ
// 引数2:サブセット計算対象のビットマップセットのポインタ
// 戻り値:true:サブセットである,false:サブセットでない
//         aがNULLの場合,true
//         bがNULLの場合,bms_is_empty(a)
extern bool bms_is_subset(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- aがbのサブセットであるか計算する。

&size(12){&color(white,orange){ 参考 };}; [[bms_is_subset()>https://doxygen.postgresql.org/bitmapset_8c.html#a42a54266b296035d38e928e95679a0dd]] - on doxygen.postgresql.org

*** bms_subset_compare [#h2821fd9]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:比較対象のビットマップセットのポインタ
// 引数2:比較対象のビットマップセットのポインタ
// 戻り値:関連を示す列挙定数
extern BMS_Comparison bms_subset_compare(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- aとbの関連を調べる。
- bms_is_subset関数では左右入れ替えて計算する必要があるが,この関数では一度の実行で関連を調べられる。

&size(12){&color(white,orange){ 参考 };}; [[bms_subset_compare()>https://doxygen.postgresql.org/bitmapset_8h.html#a2807a0e6468a3038840045e4503c63b4]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_subset()
{
    Bitmapset *bma = bms_make_singleton(0);
    bma = bms_add_member(bma, 1);
    bma = bms_add_member(bma, 12);

    Bitmapset *bmb = bms_make_singleton(0);
    bmb = bms_add_member(bmb, 1);
    bmb = bms_add_member(bmb, 12);
    bmb = bms_add_member(bmb, 16);
    bmb = bms_add_member(bmb, 32);

    elog(NOTICE, "Is a subset of b ? -> %d", bms_is_subset(bma, bmb)); // a ⊆ b
    elog(NOTICE, "Is b subset of a ? -> %d", bms_is_subset(bmb, bma)); // b ⊆ a

    BMS_Comparison relship = bms_subset_compare(bma, bmb);
    switch (relship) {
    case BMS_EQUAL:
        elog(NOTICE, "a = b");
        break;
    case BMS_SUBSET1:
        elog(NOTICE, "a ⊆ b");
        break;
    case BMS_SUBSET2:
        elog(NOTICE, "b ⊆ a");
        break;
    case BMS_DIFFERENT:
        elog(NOTICE, "a != b");
        break;
    default:
        elog(NOTICE, "not arrive here");
        break;
    } 
}

/* Output is the following:
------------------------------
NOTICE:  Is a subset of b ? -> 1
NOTICE:  Is b subset of a ? -> 0
NOTICE:  a ⊆ b
*/
}}}
*** bms_is_member [#acdf2980]

#geshi(c){{{
// 引数1:チェックしたい整数
// 引数2:対象のビットマップセットのポインタ
// 戻り値:true:メンバーである,false:メンバーでない
//         xが負数の場合は,エラー
//         aがNULLの場合は,false
extern bool bms_is_member(int x, const Bitmapset *a);
}}}

- xがビットマップセットの要素であるかを確認する。

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
Bitmapset *bm = bms_make_singleton(1);
elog(NOTICE, "%u", bms_is_member(1, bm)); // NOTICE:  1
}}}

*** bms_overlap [#lb65755b]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:true:オーバーラップあり,false:オーバーラップなし
//         aまたはbがNULLの場合,false
extern bool bms_overlap(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- 指定されたビットマップセットの一方が他方とオーバーラップしているかを調べる。

&size(12){&color(white,orange){ 参考 };}; [[bms_overlap()>https://doxygen.postgresql.org/bitmapset_8c.html#ad07cdfd7f2600d45125ac502567d1476]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_overlap()
{
    Bitmapset *bma = bms_make_singleton(0);
    bma = bms_add_member(bma, 1);
    bma = bms_add_member(bma, 12);

    Bitmapset *bmb = bms_make_singleton(0);
    bmb = bms_add_member(bmb, 1);
    bmb = bms_add_member(bmb, 12);
    bmb = bms_add_member(bmb, 16);
    bmb = bms_add_member(bmb, 32);

    // 1, 12 are overlaps
    elog(NOTICE, "Is there a overlap between bma and bmb ? %d", bms_overlap(bma, bmb));
}

/* Output is the following:
------------------------------
NOTICE:  Is there a overlap between bma and bmb ? 1
*/
}}}

*** bms_nonempty_difference [#f34c0e39]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:true:差分あり,false:差分なし
//         aがNULLの場合は,false
//         bがNULLに場合は,!bms_is_empty(a)の結果
extern bool bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- a-bに空でない差分があるかを調べる。

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_nonempty_difference()
{
    Bitmapset *bma = bms_make_singleton(0);
    bma = bms_add_member(bma, 1);
    bma = bms_add_member(bma, 12);
    bma = bms_add_member(bma, 16);

    Bitmapset *bmb = bms_make_singleton(0);
    bmb = bms_add_member(bmb, 1);
    bmb = bms_add_member(bmb, 12);
    bmb = bms_add_member(bmb, 16);
    bmb = bms_add_member(bmb, 32);

    // 32 is nonempty_difference
    elog(NOTICE, "Is there a diffrence between bmb and bmb ? %d", bms_nonempty_difference(bmb, bma));
}

/* Output is the following:
------------------------------
NOTICE:  Is there a diffrence between bmb and bmb ? 1
*/
}}}

*** bms_singleton_member [#c614c16d]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:シングルトンメンバの値
//         aがNULLの場合,エラー
//         aがemptyの場合,エラー
extern int bms_singleton_member(const Bitmapset *a);
}}}

- シングルトンメンバの値を返す。

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
Bitmapset *bm = bms_make_singleton(31);
elog(NOTICE, "%d", bms_singleton_member(bm)); // NOTICE:  31
}}}

*** bms_get_singleton_member [#n55ddd34]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 引数2:シングルトンメンバを書き込むポインタ
// 戻り値:true:取得OK,false:失敗
//         aがemtpyの場合,false 
extern bool bms_get_singleton_member(const Bitmapset *a, int *member);
}}}

- ビットマップセットのシングルトンメンバの値を取得する。

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset()
{
    Bitmapset *bm = bms_make_singleton(31);
    int x = -1;
    if (bms_get_singleton_member(bm, &x)) {
        elog(NOTICE, "x = %d", x); // NOTICE:  31
    }
}
}}}

*** bms_num_members [#wf426c00]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:要素数
//         aがNULLの場合,0
extern int bms_num_members(const Bitmapset *a);
}}}

- ビットマップセットの要素数をカウントする。

&size(12){&color(white,#00afcc){ サンプル };};

#geshi(c){{{
void test_bitmapset()
{
    Bitmapset *bm = bms_make_singleton(0);

    for (int i = 1; i <= 10; i++) {
        bm = bms_add_member(bm, i);
    }
    // nwords is extended from 1 to 2
    bm = bms_add_member(bm, 32);

    // count members of set over words
    elog(NOTICE, "num = %d", bms_num_members(bm)); // NOTICE:  num = 12
}
}}}

*** bms_membership [#u1d80489]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:メンバーシップの列挙定数
extern BMS_Membership bms_membership(const Bitmapset *a);
}}}

- ビットマップセットのメンバーシップを取得する。

*** bms_is_empty [#t399eda7]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:true:空,false:空でない
//         aがNULLの場合,true
extern bool bms_is_empty(const Bitmapset *a);
}}}

- ビットマップセットが空かどうか確認する。

*** bms_add_member [#u170c17d]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 引数2:ビットマップセットに加える要素
// 戻り値:ビットマップセットのポインタ
//         xが負数の場合,エラー
//         aがNULLの場合,bms_make_singleton(x)
extern Bitmapset *bms_add_member(Bitmapset *a, int x);
}}}

- ビットマップセットに要素xを加える。
- &color(red){Bitmapsetは指定される要素値に応じて拡張されるので,関数から戻されるビットマップのポインタを使うように注意する。};

&size(12){&color(white,orange){ 参考 };}; [[bms_add_member()>https://doxygen.postgresql.org/bitmapset_8h.html#a6b969eb0ff1820a773b7cd8f9f1a92d5]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
Bitmapset *bm = bms_make_singleton(0);
bm = bms_add_member(bm, 32);
}}}

*** bms_del_member [#i5fea93d]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 引数2:削除する要素
// 戻り値:ビットマップセットのポインタ
//         xが負数の場合,エラー
//         aがNULLの場合,NULL
extern Bitmapset *bms_del_member(Bitmapset *a, int x);
}}}

- ビットマップセットから要素xを削除する。

*** bms_add_members [#q8de13fa]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:和集合演算されたビットマップセットのポインタ
//         aがNULLの場合,bms_copy(a)
//         bがNULLの場合,a
//         nwordsが大きい方に統合される,aは再利用される
extern Bitmapset *bms_add_members(Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- 指定されたビットマップの和集合を計算する。
- &color(red){aは再利用される。};

&size(12){&color(white,orange){ 参考 };}; [[bms_add_members()>https://doxygen.postgresql.org/bitmapset_8h.html#a7eca26d8ed0ecc57884ad362c9102ed6]] - on doxygen.postgresql.org

*** bms_int_members [#l59605a2]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:積集合演算されたビットマップセットのポインタ
//         aがNULLの場合,NULL
//         bがNULLの場合,pfree(a)してNULL,aは再利用される
extern Bitmapset *bms_int_members(Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- 指定されたビットマップの積集合を計算する。
- &color(red){aは再利用される。};

*** bms_del_members [#d36bd21a]

#geshi(c){{{
// 引数1:
// 引数2:
// 戻り値:
// 引数1:対象のビットマップセットのポインタ
// 引数2:対象のビットマップセットのポインタ
// 戻り値:差集合演算されたビットマップセットのポインタ
//         aがNULLの場合,NULL
//         bがNULLの場合,a
extern Bitmapset *bms_del_members(Bitmapset *a, const Bitmapset *b);
}}}
- 説明

- 指定されたビットマップの差集合を計算する。

*** bms_join [#e146e2df]

#geshi(c){{{
// 引数1:対象のビットマップセット1のポインタ
// 引数2:対象のビットマップセット2のポインタ
// 戻り値:結合されたビットマップセットのポインタ
// 戻り値:和集合演算されたビットマップセットのポインタ
//         aがNULLの場合,b
//         bがNULLの場合,a
//         aもbも再利用される
extern Bitmapset *bms_join(Bitmapset *a, Bitmapset *b);
}}}

- 指定されたビットマップセットを結合した結果を返す。
- サイズの大きな方に統合される。
- &color(red){関数実行において,指定されたビットマップセットのいずれかのポインタがpfreeされることがあるため注意。};
- 指定されたビットマップセットの和集合を計算する。
- &color(red){aもbも再利用される。};

&size(12){&color(white,orange){ 参考 };}; [[bms_join()>https://doxygen.postgresql.org/bitmapset_8c.html#a24f7dc4716c59c7ffe509e2682b8a808]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_join()
{
    Bitmapset *bm1 = bms_make_singleton(1);
    Bitmapset *bm2 = bms_make_singleton(4);

//    Bitmapset *bm3 = bms_join(bm, bm2);
    // bms_joinでは,引数で指定したビットマップセットを再利用する(変更される)
    Bitmapset *bm3 = bms_join(bms_copy(bm1), bms_copy(bm2));
    int result = -1;

    result = -1;
    elog(INFO, "%s", "***** bm3 *****");
    while ((result = bms_first_member(bm3)) >= 0) {
        elog(INFO, "member: %d", result);
    }

    result = -1;
    elog(INFO, "%s", "***** bm1 *****");
    while ((result = bms_first_member(bm1)) >= 0) {
        elog(INFO, "member: %d", result);
    }

    result = -1;
    elog(INFO, "%s", "***** bm2 *****");
    while ((result = bms_first_member(bm2)) >= 0) {
        elog(INFO, "member: %d", result);
    }
}

/* Output is the following:
------------------------------
INFO:  ***** bm3 *****
INFO:  member: 1
INFO:  member: 4
INFO:  ***** bm1 *****
INFO:  member: 1
INFO:  ***** bm2 *****
INFO:  member: 4
*/
}}}
*** bms_first_member [#f07f3371]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:ビットマップセットの最初の要素
//        空の場合は-1が返される
//         aがNULLの場合,-1
//         aがemptyの場合,-1
extern int bms_first_member(Bitmapset *a);
}}}

- ビットマップセットの要素値を返す。
- ビットマップセットの取り出された要素値は,ビットマップセットから削除される(&color(red){破壊的に操作されるので注意};)。
- ビットマップセットの最初の要素値を返す。
- ビットマップセットの取り出された要素値は,ビットマップセットから削除される(&color(red){破壊的に操作されるので注意};)。

&size(12){&color(white,orange){ 参考 };}; [[bms_first_member()>https://doxygen.postgresql.org/bitmapset_8c.html#aea2096ee0dbd28ca870fcf9ca9ab910d]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_iterate()
{
    Bitmapset *bm = bms_make_singleton(0);
    bm = bms_add_member(bm, 0);
    bm = bms_add_member(bm, 1);
    bm = bms_add_member(bm, 2);

    int result = -1;
    while ((result = bms_first_member(bm)) >= 0) {
        elog(INFO, "member: %d", result);
    }

    // members is already removed from bitmapset.
    elog(INFO, "% is member of bm ? %d", 1, bms_is_member(1, bm)); // 削除されているのでfalse
}

/* Output is the following:
--------------------------
INFO:  member: 0
INFO:  member: 1
INFO:  member: 2
INFO:   1s member of bm ? 0
*/
}}}

*** bms_next_member [#l584c45b]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 引数2:要素値(この要素値以上で最小の要素が検索される)
// 戻り値:-2:次の要素なし,0以上:要素値
//         aがNULLの場合,-2
//         aが空の場合,-2
extern int bms_next_member(const Bitmapset *a, int prevbit);
}}}

- 指定された要素値以上で最小の要素値を返す。
- 指定された要素値prevbit以上で最小の要素値を返す。
- prevbitは-1以下であってはいけない。
- bms_next_member関数は,bms_first_member関数と異なり,ビットマップセット自体は書き換えない。
- bms_next_member関数は,bms_first_member関数と異なりビットマップセット自体は書き換えない。


&size(12){&color(white,orange){ 参考 };};
- [[bms_next_member()>https://doxygen.postgresql.org/bitmapset_8h.html#a2a4b3a10e18b42ec38db57dbceaf471a]] - on doxygen.postgresql.org
- [[bms_first_member()>https://doxygen.postgresql.org/bitmapset_8c.html#aea2096ee0dbd28ca870fcf9ca9ab910d]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_iterate2()
{
    Bitmapset *bm = bms_make_singleton(0);
    bm = bms_add_member(bm, 0);
    bm = bms_add_member(bm, 1);
    bm = bms_add_member(bm, 19);
    bm = bms_add_member(bm, 32);
    bm = bms_add_member(bm, 64);
    elog(INFO, "%s", "***** first iterate *****");
    int result = -1;
    while ((result = bms_next_member(bm, result)) >= 0) {
        elog(INFO, "member: %d", result);
    }
    elog(INFO, "%s", "***** second iterate *****");
    result = -1;
    while ((result = bms_next_member(bm, result)) >= 0) {
        elog(INFO, "member: %d", result);
    }
}

/* Output is the following:
------------------------------
INFO:  ***** first iterate *****
INFO:  member: 0
INFO:  member: 1
INFO:  member: 19
INFO:  member: 32
INFO:  member: 64
INFO:  ***** second iterate *****
INFO:  member: 0
INFO:  member: 1
INFO:  member: 19
INFO:  member: 32
INFO:  member: 64
*/
}}}
*** bms_hash_value [#e541a454]

#geshi(c){{{
// 引数1:対象のビットマップセットのポインタ
// 戻り値:ハッシュ値,空の場合は0
// 戻り値:ハッシュ値
//         aがNULLの場合,0
//         aがemptyの場合,0
extern uint32 bms_hash_value(const Bitmapset *a);
}}}

- 指定されたビットマップセットのハッシュ値を返す。
- ビットマップセットが空の場合は0が返る。

&size(12){&color(white,orange){ 参考 };}; [[bms_hash_value()>https://doxygen.postgresql.org/bitmapset_8h.html#a2d2fc486e11ee76456aefa9069843ee6]] - on doxygen.postgresql.org

&size(12){&color(white,#00afcc){ サンプル };};
#geshi(c){{{
void test_bitmapset_hash()
{
    Bitmapset *bm = bms_make_singleton(0);
    bms_del_member(bm, 0);
    // empty set
    elog(INFO, "hash value = %u", bms_hash_value(bm));

    bm = bms_add_member(bm, 0);
    bm = bms_add_member(bm, 1);
    bm = bms_add_member(bm, 2);
    elog(INFO, "hash value = %u", bms_hash_value(bm));

    bm = bms_add_member(bm, 4);
    elog(INFO, "hash value = %u", bms_hash_value(bm));
}


/* Output is the following:
------------------------------
INFO:  hash value = 0
INFO:  hash value = 3316173823
INFO:  hash value = 1671777080
*/
}}}
* サンプルプログラム [#n657ef28]

** ビットマップセットのビットを表示する [#l9a28529]

&size(12){&color(white,#800080){ 実験 };};

#geshi(c){{
// ワードのビットを表示する
void show_bit(Bitmapset *bm, int x)
{
    elog(NOTICE, "*** added member: %d *** ", x);

    StringInfoData str;
    initStringInfo(&str);
    for (int n = 0, wordnum = bm->nwords; n < wordnum; n++) {
        bitmapword b = bm->words[n];
        elog(NOTICE, "words[%d] = %u", n, b);
        for (int i = BITS_PER_BITMAPWORD - 1; i >= 0; i--) {
            appendStringInfo(&str, "%u", (b >> i) & (bitmapword) 1);
        }
        elog(NOTICE, "%s", str.data);
        resetStringInfo(&str);
    }
    // pfree(str.data);
}

void sample()
{
    Bitmapset *bm = bms_make_singleton(0);

    bm = bms_add_member(bm, 0);
    show_bit(bm, 0);
    bm = bms_add_member(bm, 1);
    show_bit(bm, 1);
    bm = bms_add_member(bm, 2);
    show_bit(bm, 2);

    bm = bms_add_member(bm, 31);
    show_bit(bm, 31);

    bm = bms_add_member(bm, 32);
    show_bit(bm, 32);
}

/* Output is the following:

NOTICE:  *** added member: 0 *** 
NOTICE:  words[0] = 1
NOTICE:  00000000000000000000000000000001
NOTICE:  *** added member: 0 *** 
NOTICE:  words[0] = 1
NOTICE:  00000000000000000000000000000001
NOTICE:  *** added member: 1 *** 
NOTICE:  words[0] = 3
NOTICE:  00000000000000000000000000000011
NOTICE:  *** added member: 2 *** 
NOTICE:  words[0] = 7
NOTICE:  00000000000000000000000000000111
NOTICE:  *** added member: 31 *** 
NOTICE:  words[0] = 2147483655
NOTICE:  10000000000000000000000000000111
NOTICE:  *** added member: 32 *** 
NOTICE:  words[0] = 2147483655
NOTICE:  10000000000000000000000000000111
NOTICE:  words[1] = 1
NOTICE:  00000000000000000000000000000001
*/
}}
* 参考・関連 [#g81f45e8]

- [[bitmapset.h>https://doxygen.postgresql.org/bitmapset_8h.html]] - on doxygen.postgresql.org
- [[bitmapset.c>https://doxygen.postgresql.org/bitmapset_8c.html]] - on doxygen.postgresql.org


&size(12){&color(white,orange){ 関連 };};

#related
* コメント [#m246387f]

#comment



トップ   一覧 単語検索 最終更新   ヘルプ   最終更新のRSS
目次
ダブルクリックで閉じるTOP | 閉じる
GO TO TOP