┌──────────────────────────────────────┐
│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バイト(アライメントサイズ)までなのね。

ぶっちゃけ、セキュリティ対策って以下のことですよね？

【クロスサイトスクリプティング(XSS)対策】
  以下の五つの文字を、画面表示時に以下に置換して表示する
  ・「'」→「'」
  ・「"」→「"」
  ・「&」→「&」
  ・「<」→「&lt;」
  ・「>」→「&gt;」

【SQLインジェクション対策】
  以下の三つの文字を、SQL実行時に以下に置換して実行する
  ・「'」→「\'」
  ・「"」→「\"」
  ・「\」→「\\」
  もしくは、以下の一つの文字を、SQL実行時に以下に置換して実行する
  ・「'」→「''」
  ＃この場合は、残りの二つは機能的にSQLインジェクションを防止できていること

mb_strcut()のパラメータにマイナス値を指定してあげると、
右から抜き出すことが可能だが、端数が出た場合には端数も切り上げて抽出してしまう。
よって、指定したサイズよりも+1取得される場合がありうる。

mb_strcut(,-4)の場合
  あいうえお   →  いうえお
  あいうえおA  →  いうえおA

┌──────────────────────────────────────┐
│$抽出 = mb_strcut($文字, -4);                                               │
│if (mb_strwidth($抽出) > 4) {                                               │
│    $出力先 = '...' . mb_strcut($抽出, -3);                                 │
│} else {                                                                    │
│    $出力先 = '..' . $抽出;                                                 │
│}                                                                           │
└──────────────────────────────────────┘

ちなみに、左から普通に切り出した時も同じです。
mb_strcut(,0,4)の場合
  あいうえお   →  あいうえ
  Aあいうえお  →  Aあいうえ