プルダウンメニューを選択しようとすると、横長の文字も全て表示してくれる。
最近のブラウザ(IE9、Firefox、Chromeなど)では当たり前のことでも、
ひと昔前は当たり前じゃなかった(IEだけ？)。

とにかくIE8で文字長の長い選択肢がプルダウンメニューにあると
選択しようとするときに後ろの方が尻切れになってしまう。

これは仕方がない。

JavaScriptで対応できなくはないが、いろいろとめんどくさそうだし
完璧に対応できるかも疑問。

嵐が去る(IE8が絶滅する？)のを待つ他ない？

「serial型」もしくは「bigserial型」の列(例えばIDなど)において、
レコードを削除するなどして、歯抜けが発生した場合、
前詰にしたくなる場合がある。

以下がそのやり方。
┌──────────────────────────────────────┐
│UPDATE 表                                                                   │
│    SET 列 = (SELECT COUNT(*)                                               │
│                  FROM 表 t1,                                               │
│                       表 t2                                                │
│                  WHERE t1.列 >= t2.列                                      │
│                    AND t1.列  = 表.列                                      │
│                  GROUP BY t1.列);                                          │
├──────────────────────────────────────┤
│SELECT SETVAL ('AutoNumber用列名', (SELECT COUNT(*) FROM 表), true);        │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│UPDATE 表                                                                   │
│    SET 出力列 = TO_NUMBER(REPLACE(入力列, 'NO', ''), '000')                │
│    WHERE 入力列 LIKE '%NO%';                                               │
└──────────────────────────────────────┘
「NO1、NO2、NO10…、NO999」とかのように先頭に文字が付いている連番から
数値のみを抜き出すUPDATE文。
「REPLACE()」で置換し、「TO_NUMBER()」で数値変換といった流れだ。

PostgreSQLでも配列っていう型があるが、その中に特定の値が含まれているか
判定するには？

PHPでいうところの「in_array()」みたいなやつ。

基本的には、これ。
┌──────────────────────────────────────┐
│配列 && ARRAY[値]                                                           │
└──────────────────────────────────────┘
ただ、これだと配列が空っぽの場合はfalseではなくNULL扱いとなる

まあ、true(falseとnull以外)だけ判定する分には問題ないけど、
厳密にしたい場合は以下のような一手間を加える。
┌──────────────────────────────────────┐
│COALESCE(配列 && ARRAY[値], false)                                          │
└──────────────────────────────────────┘

これだとtrue以外を以下で判定できる。
┌──────────────────────────────────────┐
│NOT COALESCE(配列 && ARRAY[値], false)                                      │
└──────────────────────────────────────┘

ちなみに、以下のように複数の指定も可能。
┌──────────────────────────────────────┐
│配列 && ARRAY[値,値]                                                        │
└──────────────────────────────────────┘
どれかを含んでいればtrueとなる。

より実用的な複合版は以下のような感じ。
┌──────────────────────────────────────┐
│SELECT ROW_NUMBER() OVER(PARTITION BY 列,列 ORDER BY 列 ASC,列 ASC) FROM 表;│
└──────────────────────────────────────┘
「PARTITION BY」でグルーピングして、その中で「ORDER BY」で並び替える。
グルーピングは複合条件も可能で、並び替えも複合条件が可能。
上記は二件までの例だが、もちろ三件以上も可能だ。

┌──────────────────────────────────────┐
│$('#button').click(function() {                                             │
│    alert('押したね？');                                                    │
│});                                                                         │
└──────────────────────────────────────┘
上記と下記は等価。
┌──────────────────────────────────────┐
│$('#button').bind('click', function() {                                     │
│    alert('押したね？');                                                    │
│});                                                                         │
└──────────────────────────────────────┘

下記の方式だと複数イベントを束ねることができる。、
┌──────────────────────────────────────┐
│$('#text').bind('keyup keydown', function() {                               │
│    alert('押したね？');                                                    │
│});                                                                         │
└──────────────────────────────────────┘

クリックイベントとかを定義しても、最初のその時点でその要素がないと
その(まだ出現していない)要素にはイベントが反映されない。

つまりは、appendとかでボタンを追加しても、
そいつにはイベントが登録されていないわけだ。

だいたい、ボタンを出現させるってことは、そいつを押させて何かのイベントを
起こさせたりしたわけだから、ボタンの出現とともにイベントも登録したいわけだ。
＃最初に全部出現させといて、必要なもの以外隠すという手もあるが、
  全部がいくつかわからない時にはちょっと難ありだ。

で、とにかくappend後、再度イベントを登録しちゃえばいいじゃん、ということで、
append処理を行った直後にイベント処理を追記した。
┌──────────────────────────────────────┐
│$('#body')                                                                  │
│    .append($('<input>').prop('type' , 'button')                            │
│                        .val('押して')                                      │
│    );                                                                      │
├──────────────────────────────────────┤
│$(':button').click(function() {                                             │
│    alert("押したね？");                                                    │
│});                                                                         │
└──────────────────────────────────────┘
おぉ、これならいける…と思ったのだが、なんとボタンが出現する度に
イベントが多重登録されていくのであった。

で、調べたら、bindっての使えばいいらしい。
┌──────────────────────────────────────┐
│$('#body')                                                                  │
│    .append($('<input>').prop('type' , 'button')                            │
│                        .val('押して')                                      │
│                        .bind("click", function() {                         │
│                            alert("押したね？");                            │
│                        })                                                  │
│    );                                                                      │
└──────────────────────────────────────┘

「char」型と「signed char」型は違う…らしい。

「char」型 vs 「signed char」型 vs 「signed char」型

で、

「char」型＝「signed char」型

かと、思ったんだけどね。


「int」型はいいっぽい。

「int」型＝「signed int」型≠「unsigned int」型

C言語にはbool型ってものが元々なくて、途中から追加された。

だけど、bool型ってのはそれまでに独自でそれぞれ使われていたので
「_Bool」型という控えめな名前で定義した。

これを「bool」型として使用できるように、インクルードファイル「stdbool.h」で
小細工をしている。

で、本体の「_Bool」型とは何かというと？符号無し整数型で
「0」と「1」を格納できればいいってだけで、後は機種依存らしい。

処理速度が速い「int」型を採用している場合もあれば、
サイズが小さい「char」型だったりする場合もある
(さすがにビットは扱いづらすぎてないようだが)。

だから「sizeof(bool)」は「1」だったり「4」だったりする。

それと後から追加されたものだから厳密ではないらしく
他の型と演算できてしまったりするらしい。

ただし、利点としては「0」か「1」しか値をとらないように
最低限保証はしてくれる模様。

ま、ソースコードが読みやすいってもの大きいかも。

┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    int   a1;                                                               │
│    char  a2;                                                               │
│} A;                                                                        │
│sizeof(A)  →  8(4 + 1 + 3)                                                 │
└──────────────────────────────────────┘
構造体はアライメントサイズまで末尾を埋めてくれる、上記のように。

と思っていたのだが、char型だけだとそうはいかなかった。
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    char  a1[3];                                                            │
│} A;                                                                        │
│sizeof(A)  →  3                                                            │
└──────────────────────────────────────┘
ちなみに、複数配列にしてみても状況は変わらない。
┌──────────────────────────────────────┐
│A z[2];                                                                     │
│sizeof(z)  →  6                                                            │
└──────────────────────────────────────┘

じゃ、メンバを分けてみたら…同じだ。
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    char  a1;                                                               │
│    char  a2[2];                                                            │
│} A;                                                                        │
│sizeof(A)  →  3                                                            │
└──────────────────────────────────────┘

じゃ、じゃ、int型以外にしてみたら…同じだ。
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    bool  a1;                                                               │
│    char  a2[2];                                                            │
│} A;                                                                        │
│sizeof(A)  →  3                                                            │
└──────────────────────────────────────┘

shortとかにしてみたら？
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    short a1;                                                               │
│    char  a2[3];                                                            │
│} A;                                                                        │
│sizeof(A)  →  6                                                            │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    short a1;                                                               │
│    char  a2;                                                               │
│} A;                                                                        │
│sizeof(A)  →  4                                                            │
└──────────────────────────────────────┘

あ、わかった一番大きなものに追従するの？
┌──────────────────────────────────────┐
│typedef struct {                                                            │
│    longlong  a1;                                                           │
│    char      a2;                                                           │
│} A;                                                                        │
│sizeof(A)  →  8                                                            │
└──────────────────────────────────────┘
あ、でも最大でも4バイト(アライメントサイズ)までなのね。