「1～10」の値をSmartyだけで出力する方法。
┌──────────────────────────────────────┐
│{section name=cnt start=1 loop=11}                                          │
│{$smarty.section.cnt.index}<br/>                                            │
│{/section}                                                                  │
└──────────────────────────────────────┘
「for ($i = 1; $i < 11; $i++) {～」みたいなイメージだ。

ちなみにゼロパディングして「01～10」を出力する場合は、こう。
┌──────────────────────────────────────┐
│{section name=cnt start=1 loop=11}                                          │
│{$smarty.section.cnt.index|string_format:'%02d'}<br/>                       │
│{/section}                                                                  │
└──────────────────────────────────────┘
「printf(%02d, $i)」って感じかな。

文字コードを変換する関数は「mb_convert_encoding()」。
以下のような感じ「UTF-8←SJIS-win」の方向に変換される。
┌──────────────────────────────────────┐
│$変換後 = mb_convert_encoding($変換前, 'UTF-8', 'SJIS-win');                │
└──────────────────────────────────────┘

これに便利なオプション「auto」ってのがあって、
こんな風に指定してあげると
SJISだろうがEUCだろうがもちろん自身UTF-8も含めてすべてUTF-8に変換してくれる。
＃自身UTF-8の場合は変換しないでくれるってことだね、
  とにかくどうあえれ結果はすべてUTF-8になるのだ、便利
┌──────────────────────────────────────┐
│$変換後 = mb_convert_encoding($変換前, 'UTF-8', 'auto');                    │
└──────────────────────────────────────┘

でも、注意しなければならない。
事前に以下の設定を行っておく必要があるのだ。
┌──────────────────────────────────────┐
│mb_language('Japanese');                                                    │
└──────────────────────────────────────┘
これからやる処理は日本語だって宣言しなきゃならないんだね。
これに気がつかないと「auto」オプションなんて使えねぇって勘違いをすることになる。

ちなみに、SJISとUTF-8が混じった文字列みたいなのを変換しようとすると
どっちかが優先されて他方が文字化けしてしまうので注意が必要だ。

IEで以下のJavaScriptエラーが出た場合の原因
┌──────────────────────────────────────┐
│ライン:1000                                                                 │
│文字:1                                                                      │
│エラー:オブジェクトを指定してください                                       │
│コード:0                                                                    │
└──────────────────────────────────────┘

JavaScript外部ファイルのアサイン順番の間違い。
例）jQueryをアサインする前に、jQueryを使用しているJavaScript外部ファイルを
    アサインした

以下のように同じ処理を複数のセレクタに同じように書いているのを…。
┌──────────────────────────────────────┐
│$("#a").click(function() {                                                  │
│  alert("該当しました");                                                    │
│});                                                                         │
│$("#b").click(function() {                                                  │
│  alert("該当しました");                                                    │
│});                                                                         │
└──────────────────────────────────────┘

以下のようにまとめられるのであった。
┌──────────────────────────────────────┐
│$("#a,#b").click(function() {                                               │
│  alert("該当しました");                                                    │
│});                                                                         │
└──────────────────────────────────────┘

OR条件は「,」なのだね

値を加算するSQL文は以下の通り。
┌──────────────────────────────────────┐
│UPDATE 表                                                                   │
│    SET 列 = 列 + 値                                                        │
│    WHERE 条件;                                                             │
└──────────────────────────────────────┘
SELECTで読み出して、プログラム的に加算して、UPDATEで書き込む、
みたいな処理は不要で、一発で加算できるわけだ。
これなら排他処理が軽減(単体としては不要)される。

もちろん、減算とかにも応用できる。

適当な欠番「id」に「値」を設定するとすると、以下のような感じになる。
┌──────────────────────────────────────┐
│UPDATE 表                                                                   │
│    SET `id` = 値                                                           │
│    WHERE `id` IS NULL                                                      │
│    ORDER BY rand()                                                         │
│    LIMIT 1;                                                                │
└──────────────────────────────────────┘

「id」がユニークキー(たいていは主キー)で、
ひょっとしてその値が既に設定されているとまずいので
既に存在しないことを条件追加して相関副問い合わせ化したら
以下のような感じになった。
┌──────────────────────────────────────┐
│UPDATE 表                                                                   │
│    SET `id` = 値                                                           │
│    WHERE `id` IS NULL                                                      │
│      AND NOT EXISTS (SELECT `id`                                           │
│                          FROM 表                                           │
│                          WHERE `id` = 値                                   │
│                     )                                                      │
│    ORDER BY rand()                                                         │
│    LIMIT 1;                                                                │
└──────────────────────────────────────┘
でも、エラーになります。
「#1093 - You can't specify target table '表' for update in FROM clause」

要は副問い合わせの中に主問い合わせと同じ表を使えないらしい。

仕方ないのでとりあえず、参照してから条件分岐で更新することにした。
なんかいい方法はないものか。

先日にも触れたが、「LEFT JOIN」って直積なのをついつい忘れがちになる。
メインデータを一回のSQL発行で取得して、
それをループして一件ずつサブデータをSQL発行で取得してマージしていく…、
みたいな処理を一回のSQL発行でできるのが「LEFT JOIN」なのかなと錯覚してしまう。
当然、名称取得などサブデータが一件の場合はその通りなのだが、
カウントした件数をマージしたりする場合は注意が必要だ。

これはOK。
┌──────────────────────────────────────┐
│SELECT メイン表.ID,                                                         │
│       サブ表.サブ名称                                                      │
│    FROM メイン表                                                           │
│        LEFT JOIN サブ表                                                    │
│          ON サブ表.ID = メイン表.サブID;                                   │
└──────────────────────────────────────┘
サブ名称を参照するケースだ。

これはギリギリOK。
┌──────────────────────────────────────┐
│SELECT メイン表.ID,                                                         │
│       COUNT(サブ表.ID) AS サブ該当件数                                     │
│    FROM メイン表                                                           │
│        LEFT JOIN サブ表                                                    │
│          ON サブ表.キーID = メイン表.サブキーID                            │
│    GROUP BY メイン表.ID;                                                   │
└──────────────────────────────────────┘
サブ表中にサブキーIDに該当するものが何件あるかをマージするケース。

でも、これはNG、件数が二つになったらNG。
┌──────────────────────────────────────┐
│SELECT メイン表.ID,                                                         │
│       COUNT(サブ表1.ID) AS サブ1該当件数,                                  │
│       COUNT(サブ表2.ID) AS サブ2該当件数                                   │
│    FROM メイン表                                                           │
│        LEFT JOIN サブ表1                                                   │
│          ON サブ表1.キーID = メイン表.サブ1キーID                          │
│        LEFT JOIN サブ表2                                                   │
│          ON サブ表2.キーID = メイン表.サブ2キーID                          │
│    GROUP BY メイン表.ID;                                                   │
└──────────────────────────────────────┘
サブ1とサブ2で各々で件数を算出してくれるかと思いきや、直積により、
それぞれの該当件数が両者の掛け算の結果(つまり同一値)になってしまうのだ。

対抗策１、DISTINCTをつける。
┌──────────────────────────────────────┐
│SELECT メイン表.ID,                                                         │
│       COUNT(DISTINCT サブ表1.ID) AS サブ1該当件数,                         │
│       COUNT(DISTINCT サブ表2.ID) AS サブ2該当件数                          │
│    FROM メイン表                                                           │
│        LEFT JOIN サブ表1                                                   │
│          ON サブ表1.キーID = メイン表.サブ1キーID                          │
│        LEFT JOIN サブ表2                                                   │
│          ON サブ表2.キーID = メイン表.サブ2キーID                          │
│    GROUP BY メイン表.ID;                                                   │
└──────────────────────────────────────┘
直積に対抗するにはDISTINCTとばかりに、各々にDISTINCTをつける。
こんなところにDISTINCTを置けるのか不安だったが意外にいける。

対抗策２、サブクエリとする。
┌──────────────────────────────────────┐
│SELECT メイン表.ID,                                                         │
│       (SELECT COUNT(サブ表1.ID)                                            │
│            FROM サブ表1                                                    │
│            WHERE サブ表1.キーID = メイン表.サブ1キーID                     │
│       ) AS サブ1該当件数,                                                  │
│       (SELECT COUNT(サブ表2.ID)                                            │
│            FROM サブ表2                                                    │
│            WHERE サブ表2.キーID = メイン表.サブ2キーID                     │
│       ) AS サブ2該当件数                                                   │
│    FROM メイン表;                                                          │
└──────────────────────────────────────┘
メインデータに対してサブデータをマージするというイメージには、
こっちの方が近いのだろう。
対抗策１だと直積で一旦メインデータを増殖させて、GROUP BYで収束させているが
これだとメインデータはそのままだ。
それにしても()の中に()の外側のメイン表が突然出てくる感じがして
若干違和感があった(JOINしてないから)、でもサブクエリってそんなもの。

対抗策３、UNIONを使う力業。
┌──────────────────────────────────────┐
│SELECT 新メイン表.ID,                                                       │
│       SUM(新メイン表.サブ1該当件数) AS サブ1該当件数,                      │
│       SUM(新メイン表.サブ2該当件数) AS サブ2該当件数                       │
│    FROM (SELECT メイン表.ID,                                               │
│                 NULL              AS サブ1該当件数,                        │
│                 NULL              AS サブ2該当件数                         │
│               FROM メイン表                                                │
│          UNION ALL                                                         │
│          SELECT メイン表.ID,                                               │
│                 COUNT(サブ表1.ID) AS サブ1該当件数,                        │
│                 NULL              AS サブ2該当件数                         │
│               FROM メイン表,                                               │
│                    サブ表1                                                 │
│               WHERE メイン表.サブ1キーID = サブ表1.キーID                  │
│               GROUP BY メイン表.ID                                         │
│          UNION ALL                                                         │
│          SELECT メイン表.ID,                                               │
│                 NULL              AS サブ1該当件数,                        │
│                 COUNT(サブ表2.ID) AS サブ2該当件数                         │
│               FROM メイン表,                                               │
│                    サブ表2                                                 │
│               WHERE メイン表.サブ2キーID = サブ表2.キーID                  │
│               GROUP BY メイン表.ID                                         │
│         ) AS 新メイン表                                                    │
│    GROUP BY 新メイン表.ID;                                                 │
└──────────────────────────────────────┘
こんな感じかな(動作確認してないからちょっと違うかも)。
対抗策３はあくまで余談です。

「id」が「0」(欠番)の適当な5件を「1」にするSQL文は以下の通り。
┌──────────────────────────────────────┐
│UPDATE `表`                                                                 │
│    SET `id` = '1'                                                          │
│    WHERE `id` = '0'                                                        │
│    ORDER BY rand()                                                         │
│    LIMIT 5;                                                                │
└──────────────────────────────────────┘
UPDATEでも「ORDER BY rand()」と「LIMIT」が使えるのは便利かも。

ある列がNULLでないものを抽出するSQL文。

┌──────────────────────────────────────┐
│SELECT * FROM 表 WHERE 列 IS NOT NULL;                                      │
└──────────────────────────────────────┘
これだとOK。

でも、これだと(NULLでない行があっても)「該当なし」になってしまう。
┌──────────────────────────────────────┐
│SELECT * FROM 表 WHERE 列 <> NULL;                                          │
└──────────────────────────────────────┘

NULLじゃないんだからいいと思ったんだけどなぁ…
やっぱり、「IS NOT NULL」ってのがあるんだから、そう書かないとダメみたいね。
気をつけないと。

「ID=0」のつもりで「ID=NULL」を変数で使ってるケースは結構あるもんだ。
こんな場合、SQL文を使う瞬間は注意です。

こういう階層になってて…
┌──────────────────────────────────────┐
│<div id="a">                                                                │
│  <div id="aa">                                                             │
└──────────────────────────────────────┘
「ID="a"」の子セレクタ「ID="aa"」を指定したいって時に出くわした。

┌──────────────────────────────────────┐
│#a > #aa                                                                    │
└──────────────────────────────────────┘
とかかな？と悩んだが…

IDって親だろう子だろうが全体で一意なので
┌──────────────────────────────────────┐
│#aa                                                                         │
└──────────────────────────────────────┘
で、いいんです。

こんな単純なことだが、いろいろやってると混乱してしまうのだ。
手を読みすぎて二歩を犯してしまったり、合併の繰り返しで
自社株を大量に保有してしまうようなもんだ。(例えがわかりにくい？)