特定の接頭辞を置換する例は以下のような感じとなる。
┌──────────────────────────────────────┐
│UPDATE 表 SET 列 = regexp_replace(列,'^接頭辞','');                         │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│SELECT current_timestamp;                                                   │
└──────────────────────────────────────┘
の代替。
┌──────────────────────────────────────┐
│SELECT CASE                                                                 │
│         WHEN current_timestamp < '2001-01-01 00:00:00' THEN                │
│           current_timestamp + '49710 days' + '23295 seconds'               │
│         ELSE                                                               │
│           current_timestamp                                                │
│       END AS "now";                                                        │
└──────────────────────────────────────┘
viewにしてでもお使いください。

って、いいのかい？

「'49710 days' + '23295 seconds'」の根拠がわからん。
実地試験で一番近い値はこれだった。

ついでに、
┌──────────────────────────────────────┐
│SELECT current_date;                                                        │
└──────────────────────────────────────┘
の代替
┌──────────────────────────────────────┐
│SELECT CASE                                                                 │
│         WHEN current_timestamp < '2001-01-01 00:00:00' THEN                │
│           CAST(current_timestamp + '49710 days' + '23295 seconds' AS DATE) │
│         ELSE                                                               │
│           CAST(current_timestamp AS DATE)                                  │
│       END AS "date";                                                       │
└──────────────────────────────────────┘

読込系処理で共有ロックをかける場合の処理の流れ
┌──────────────────────────────────────┐
│int           fd;                                                           │
│struct flock  ファイルロック構造体;                                         │
├──────────────────────────────────────┤
│fd = open(ファイル名,                                                       │
│          O_RDONLY,                                // 読込専用でオープンする│
│          0444);                                                            │
│if (fd == -1) {                                                             │
│    オープン失敗;                                                           │
│    exit(EXIT_FAILURE);                                                     │
│}                                                                           │
├──────────────────────────────────────┤
│ファイルロック構造体.l_type   = F_RDLCK;                       // 共有ロック│
│ファイルロック構造体.l_whence = SEEK_SET;                                   │
│ファイルロック構造体.l_start  = 0;                                          │
│ファイルロック構造体.l_len    = 16;                                         │
│戻り値 = fcntl(fd,                                                          │
│               F_SETLK,                                    // ロックをかける│
│               &ファイルロック構造体);                                      │
│if (戻り値 == -1) {                                                         │
│    他でロック中を検出;                                                     │
│}                                                                           │
├──────────────────────────────────────┤
│読込処理など                                                                │
├──────────────────────────────────────┤
│close(fd);                                             // アンロックも兼ねる│
└──────────────────────────────────────┘
・ファイル先頭から16バイト分の領域についてロックを行う
────────────────────────────────────────
書込系処理で排他ロックをかける場合の処理の流れ
┌──────────────────────────────────────┐
│int           fd;                                                           │
│struct flock  ファイルロック構造体;                                         │
├──────────────────────────────────────┤
│fd = open(ファイル名,                                                       │
│          O_RDWR,                                  // 読書両用でオープンする│
│          0666);                                                            │
│if (fd == -1) {                                                             │
│    オープン失敗;                                                           │
│    exit(EXIT_FAILURE);                                                     │
│}                                                                           │
├──────────────────────────────────────┤
│ファイルロック構造体.l_type   = F_WRLCK;                       // 排他ロック│
│ファイルロック構造体.l_whence = SEEK_SET;                                   │
│ファイルロック構造体.l_start  = 0;                                          │
│ファイルロック構造体.l_len    = 16;                                         │
│戻り値 = fcntl(fd,                                                          │
│               F_SETLK,                                    // ロックをかける│
│               &ファイルロック構造体);                                      │
│if (戻り値 == -1) {                                                         │
│    他でロック中を検出;                                                     │
│}                                                                           │
├──────────────────────────────────────┤
│書込処理など                                                                │
├──────────────────────────────────────┤
│close(fd);                                             // アンロックも兼ねる│
└──────────────────────────────────────┘
・ファイル先頭から16バイト分の領域についてロックを行う

まず、「fcntl()」を排他制御機構として使用する場合の書式は以下のような感じ。
┌──────────────────────────────────────┐
│int fcntl(fd,                                                               │
│          コマンド,                                                         │
│          *ファイルロック構造体);                                           │
└──────────────────────────────────────┘
なお、「fcntl()」はファイル制御関数なのでロック以外にも使い道がいろいろとある。
その場合には「コマンド」の部分が変わってくる。

コマンドの種別は以下の通り(排他制御機構として使用する場合のコマンドとなる)。
┌──────────────────────────────────────┐
│・F_GETLK   …ロック参照                                                    │
│・F_SETLK   …ロック設定断念                                                │
│・F_SETLKW  …ロック設定待機                                                │
└──────────────────────────────────────┘
他がロック中の場合、「F_SETLK」はエラーとしてすぐ断念するが、
「F_SETLKW」はロックが解除されるまで待つという違いがある。

ファイルロック構造体の中身を抽出すると以下のような感じ。
┌──────────────────────────────────────┐
│struct flock{                                                               │
│    short  l_type;    // ロック種類を指定する                               │
│    short  l_whence;  // ロック領域(基準位置)                               │
│    off_t  l_start;   // ロック領域(開始位置)                               │
│    off_t  l_len;     // ロック領域(長さ)                                   │
│    pid_t  l_pid;     // ロック主                                           │
│};                                                                          │
└──────────────────────────────────────┘

「l_type」に指定するロック種類は以下の通り。
┌──────────────────────────────────────┐
│・F_RDLCK  …共有ロック                                                     │
│・F_WLCLK  …排他ロック                                                     │
│・F_UNLCK  …アンロック(非ロック中)                                         │
└──────────────────────────────────────┘

「l_whence」に指定するロック領域の基準位置は以下の通り。
┌──────────────────────────────────────┐
│・SEEK_SET  …ファイル先頭                                                  │
│・SEEK_CUR  …現在位置                                                      │
│・SEEK_END  …ファイル末尾                                                  │
└──────────────────────────────────────┘
これは「fseek()」のやつと同じだ。

「l_start」は「l_whence」で指定した基準位置からの相対位置(もちろん負数も可)。
「l_len」は「l_start」からの長さ。
これらを指定することにより、ファイルの一部分をロック領域として指定できる。

「l_pid」にはロック中のプロセスID(つまりロック主)が設定されるので、
これがある場合にはその人が排他中というわけだ。

fcntl()による排他制御の場合、同一ファイルであれば
ファイルディスクリプタ(fd)が違っても、「close()」するだけで
全てについてアンロックされてしまう。
┌───────────────────────┐
│              ┌──┐            ┌────┐│
│            ┌┤fd1 │←(ロック)─┤fcntl() ││
│┌────┐│└──┘            └────┘│
││ファイル├┤    ↑(アンロック)              │
│└────┘│┌──┐            ┌────┐│
│            └┤fd2 │←─────┤close() ││
│              └──┘            └────┘│
└───────────────────────┘
上記の場合は、「fd1」を扱っている人がいつのまにか
アンロックされているって状況になりうるみたい。
注意が必要だ。

「control」の省略形って、コントロールキーだと「ctrl」なのに、
ファイルコントロールの「fcntl()」関数だと「cntl」なんだね。

紛らわしい。

WindowsXP以前であればzip圧縮を行ったファイルにパスワードをかけることができた。
しかし、WindowsVista以降からこの機能はなくなってしまった。

但し、圧縮時のパスワード設定機能がなくなっただけで、
解凍時のパスワード入力機能は残っているみたい。

よって、圧縮ツールを使ってパスワード付き圧縮ファイルを作れば
他の環境でも(たいていは)解凍できるはず。

圧縮ツールは「LhaPlus」とかがおすすめ。

「nanosleep()」で「0.1秒」スリープをする例。
┌──────────────────────────────────────┐
│struct timespec  req;                                                       │
│req.tv_sec  = 0;                                                            │
│req.tv_nsec = 100 * 1000 * 1000;                                            │
│nanosleep(&req, NULL);                                                      │
└──────────────────────────────────────┘

「timespec」構造体は以下のような内訳で、
ナノ秒は「0～999,999,999」の範囲で指定可能。
┌──────────────────────────────────────┐
│struct timespec {                                                           │
│    time_t   tv_sec;   // 秒                                                │
│    long     tv_nsec;  // ナノ秒                                            │
│};                                                                          │
└──────────────────────────────────────┘

ちなみに、シグナルで一時停止され、再度復帰した場合には
第二引数にスリープしていない残り時間が戻ってくるので
再度実行すれば、全部で想定通りの合計になるらしい。
但し、様々な理由から合計値は若干ずれる模様。
┌──────────────────────────────────────┐
│struct timespec  req,rem;                                                   │
│if (nanosleep(&req, &rem) == -1) {                                          │
│    if (errno == EINTR) {                                                   │
│        nanosleep(&rem, NULL);                                              │
│    } else {                                                                │
│        nanosleep()のエラー;                                                │
│    }                                                                       │
│}                                                                           │
└──────────────────────────────────────┘
なお、より厳密にしたい場合には「clock_nanosleep()」という関数があるらしい。

また、ナノ秒までいらず秒単位でいいのであれば「sleep()」が使える。
┌──────────────────────────────────────┐
│残り秒 = sleep(指定秒);                                                     │
│if (残り秒 > 0) {                                                           │
│    sleep(残り秒);                                                          │
│}                                                                           │
└──────────────────────────────────────┘
みたいな感じになる。

open()で取得されるファイルディスクリプタは
同一ファイル名であっても、openした順番に別の連番となる。

flock()にとる排他は、ファイルディスクリプタ単位ではなく
ファイルディスクリプタが対象とするファイル単位で行われる。

むしろ同一ファイルディスクリプタであれば排他対象外となる。

┌──────────────────────────────────────┐
│open(ファイル名,…);                           →ファイルディスクリプタ「1」│
│open(ファイル名,…);                           →ファイルディスクリプタ「2」│
│flock(1, LOCK_EX | LOCK_NB);                                        →OK(0) │
│flock(2, LOCK_EX | LOCK_NB);                                        →NG(-1)│
│flock(1, LOCK_EX | LOCK_NB);                                        →OK(0) │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│flock(fd,                                                                   │
│      LOCK_SH);                                                             │
└──────────────────────────────────────┘
基本的に「flock()」でロックをかけるが、先に他でロックをかけていた場合は
「flock()」の中でずーっと待ち状態となる。
これでは埒があかないので、「LOCK_NB」を付加して、
ロック中の場合はエラーとするようにする。
┌──────────────────────────────────────┐
│if (flock(fd, LOCK_SH | LOCK_NB) == -1) {                                   │
│    if (errno == EWOULDBLOCK) {                                             │
│        他でロック中;                                                       │
│    } else {                                                                │
│        flock()エラー;                                                      │
│    }                                                                       │
│}                                                                           │
└──────────────────────────────────────┘
ロック中で即エラーするのもなんだから、リトライ処理で囲って
若干のスリープ処理なんかを挟み込んで、気にならない程度にリトライを
試みさせてみるのもよい。
┌──────────────────────────────────────┐
│for (i = 0; i <= リトライ回数; i++ ) {                                      │
│    if (flock(fd, LOCK_SH | LOCK_NB) == -1) {                               │
│        if (errno == EWOULDBLOCK) {                                         │
│              スリープ処理;                                                 │
│              continue;                                                     │
│        } else {                                                            │
│            flock()エラー;                                                  │
│            break;                                                          │
│        }                                                                   │
│    }                                                                       │
│    ロック成功フラグ = true;                                                │
│    break;                                                                  │
│}                                                                           │
│if (!ロック成功フラグ) {                                                    │
│    close(fd);                                                              │
│    return;                                                                 │
│}                                                                           │
└──────────────────────────────────────┘