
_tl;dr_: PgCrypto는 **PKCS#7**을 사용합니다. (PgCrypto use PKCS#7)

PostgreSQL의 [pgcryto](http://www.postgresql.org/docs/9.4/static/pgcrypto.html)는 encrypt/decrypt에 padding을 어떤것으로 할 지 선택할 수 있도록 해주고 있습니다.
그런데 선택지에 대한 설명이 너무 부실합니다.
선택지가 `pkcs`와 `none`이 있는데, `none`이야 아무것도 안한다는걸 바로 알 수 있다고 쳐도 `pkcs`는 봐도 알 수가 없다는 점입니다.

> pkcs — data may be any length (default)

누가 이 설명만 보고 이것의 상세 동작을 알 수 있겠습니까?
저는 이 부실한 설명을 믿지 못하겠어서 padding을 직접 하는 쪽으로 생각하고 있었습니다.
하지만 Symmetric encryption에 대해 알아갈수록 padding을 직접 짜도 되는걸까 하는 불안감 같은것이 생겼습니다.
예를 들면 이런 이슈를 생각해보겠습니다.
encryption할 data로 blob이 왔는데 개발자가 padding으로 정한 문자가 마침 blob의 끝에 있다면?
blob은 박살나버릴 것입니다.

그럼 PgCrypto의 padding algorithm은 무엇일까요?
pkcs라는 단서밖에 없는지라 그냥 직접 소스를 뜯어보기로 했습니다.
다행히도 저장소를 직접 열어보지 않아도 [친절한 모 대학에서 PostgreSQL 9.4 소스를 문서화](http://www.comp.nus.edu.sg/~cs3223/doxygen-postgres9.4.0/html/index.html)해서 올려놔주셨습니다.
저는 [pgcrypto의 소스](http://www.comp.nus.edu.sg/~cs3223/doxygen-postgres9.4.0/html/dir_f6184a46763492249512902f212cd42e.html)를 열어서 찾아보기 시작했습니다.

> **주의**: PostgreSQL이 C로 작성된 관계로 여기서부터는 C 소스가 나옵니다.

일단 `pgcrypto.c`를 열어보기로 했습니다.
`pgcrypto.c`에는 `pg_decrypt`, `pg_decrypt_iv`, `pg_encrypt`, `pg_encrypt_iv`등의 함수가 정의되어있는데 어차피 padding은 동일한 걸 쓸것이라 생각하고 `pg_encrypt`를 보기로 했습니다.

```c
Datum
pg_encrypt(PG_FUNCTION_ARGS)
{
    int         err;
    bytea      *data,
               *key,
               *res;
    text       *type;
    PX_Combo   *c;
    unsigned    dlen,
                klen,
                rlen;

    type = PG_GETARG_TEXT_P(2);
    c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);

    data = PG_GETARG_BYTEA_P(0);
    key = PG_GETARG_BYTEA_P(1);
    dlen = VARSIZE(data) - VARHDRSZ;
    klen = VARSIZE(key) - VARHDRSZ;

    rlen = px_combo_encrypt_len(c, dlen);
    res = palloc(VARHDRSZ + rlen);

    err = px_combo_init(c, (uint8 *) VARDATA(key), klen, NULL, 0);
    if (!err)
        err = px_combo_encrypt(c, (uint8 *) VARDATA(data), dlen,
                               (uint8 *) VARDATA(res), &rlen);
    px_combo_free(c);

    PG_FREE_IF_COPY(data, 0);
    PG_FREE_IF_COPY(key, 1);
    PG_FREE_IF_COPY(type, 2);

    if (err)
    {
        pfree(res);
        ereport(ERROR,
                (errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
                 errmsg("encrypt error: %s", px_strerror(err))));
    }

    SET_VARSIZE(res, VARHDRSZ + rlen);
    PG_RETURN_BYTEA_P(res);
}
```

봐도 이해가 안갈텐데, 당연합니다.
거의 다 메크로로 되어있었습니다.
일단 함수/메크로의 이름을 보면서 대략적인 흐름을 파악해보기로 했습니다.
일단 가장 먼저 눈에 띄는 것은 `find_provider`라는 부분입니다.
일단 저것의 구현을 보면 다음과 같습니다.

```c
static void *
find_provider(text *name,
              PFN provider_lookup,
              char *desc, int silent)
{
    void       *res;
    char       *buf;
    int         err;

    buf = downcase_truncate_identifier(VARDATA(name),
                                       VARSIZE(name) - VARHDRSZ,
                                       false);

    err = provider_lookup(buf, &res);

    if (err && !silent)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("Cannot use \"%s\": %s", buf, px_strerror(err))));

    pfree(buf);

    return err ? NULL : res;
}
```

여기서 보면 알 수 있지만 처음에 `find_provider`를 실행할때 넘겨줬던 `(PFN) px_find_combo`은 함수같은 용법을 가진 것이라는것을 알 수 있습니다.

그럼 아까 전에 사용한 이제 `px_find_combo`의 정의를 살펴보았습니다.

```c
int
px_find_combo(const char *name, PX_Combo **res)
{
    int         err;
    char       *buf,
               *s_cipher,
               *s_pad;

    PX_Combo   *cx;

    cx = px_alloc(sizeof(*cx));
    memset(cx, 0, sizeof(*cx));

    buf = px_alloc(strlen(name) + 1);
    strcpy(buf, name);

    err = parse_cipher_name(buf, &s_cipher, &s_pad);
    if (err)
    {
        px_free(buf);
        px_free(cx);
        return err;
    }

    err = px_find_cipher(s_cipher, &cx->cipher);
    if (err)
        goto err1;

    if (s_pad != NULL)
    {
        if (strcmp(s_pad, "pkcs") == 0)
            cx->padding = 1;
        else if (strcmp(s_pad, "none") == 0)
            cx->padding = 0;
        else
            goto err1;
    }
    else
        cx->padding = 1;

    cx->init = combo_init;
    cx->encrypt = combo_encrypt;
    cx->decrypt = combo_decrypt;
    cx->encrypt_len = combo_encrypt_len;
    cx->decrypt_len = combo_decrypt_len;
    cx->free = combo_free;

    px_free(buf);

    *res = cx;

    return 0;

err1:
    if (cx->cipher)
        px_cipher_free(cx->cipher);
    px_free(cx);
    px_free(buf);
    return PXE_NO_CIPHER;
}
```

여기서 사용되는 `PX_Combo`는 구조체인데, 각각에 쓰일 함수포인터를 들고 있습니다.
`padding`은 `unsigned` 타입으로 되어있는데 실제로는 `bool`처럼 쓰이고 있습니다.
여기서 padding을 어떻게 할지 정하는데, 알고리즘이 세분화되어 있지는 않음을 알 수 있습니다.
`encrypt` 함수의 보다 깊은 곳을 알려면 `combo_encrypt`가 무엇인지 알아야합니다.

```c
static int
combo_encrypt(PX_Combo *cx, const uint8 *data, unsigned dlen,
              uint8 *res, unsigned *rlen)
{
    int         err = 0;
    uint8      *bbuf;
    unsigned    bs,
                bpos,
                i,
                pad;

    PX_Cipher  *c = cx->cipher;

    bbuf = NULL;
    bs = px_cipher_block_size(c);

    /* encrypt */
    if (bs > 1)
    {
        bbuf = px_alloc(bs * 4);
        bpos = dlen % bs;
        *rlen = dlen - bpos;
        memcpy(bbuf, data + *rlen, bpos);

        /* encrypt full-block data */
        if (*rlen)
        {
            err = px_cipher_encrypt(c, data, *rlen, res);
            if (err)
                goto out;
        }

        /* bbuf has now bpos bytes of stuff */
        if (cx->padding)
        {
            pad = bs - (bpos % bs);
            for (i = 0; i < pad; i++)
                bbuf[bpos++] = pad;
        }
        else if (bpos % bs)
        {
            /* ERROR? */
            pad = bs - (bpos % bs);
            for (i = 0; i < pad; i++)
                bbuf[bpos++] = 0;
        }

        /* encrypt the rest - pad */
        if (bpos)
        {
            err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen);
            *rlen += bpos;
        }
    }
    else
    {
        /* stream cipher/mode - no pad needed */
        err = px_cipher_encrypt(c, data, dlen, res);
        if (err)
            goto out;
        *rlen = dlen;
    }
out:
    if (bbuf)
        px_free(bbuf);

    return err;
}
```

이 함수의 구현을 보고나서야 드디어 padding을 실제로 어떻게 하는지 알 수 있었습니다.

```c
        if (cx->padding)
        {
            pad = bs - (bpos % bs);
            for (i = 0; i < pad; i++)
                bbuf[bpos++] = pad;
        }
```

`pad`는 `bs`(`unsigned` 타입의 cipher block size를 담은 변수)와 `bpos`를 이용해서 계산합니다.
그런데 `bpos = dlen % bs;`인데 modular 연산의 특징상 `a % b % b == a % b`입니다.
따라서 소스는 이렇게 정리가 가능합니다.

```c
pad = bs - (dlen % bs);
for (i = 0; i < pad; i++)
    bbuf[bpos++] = pad;

```

`dlen`은 `pg_encrypt`함수에서 확인이 가능한데 data의 길이를 말합니다.
이제 이렇게 암호화하는 PKCS 버전을 찾으면 됩니다.
다행히도 [StachExchange Cryptography에 이와 관련한 문서](http://crypto.stackexchange.com/questions/9043/what-is-the-difference-between-pkcs5-padding-and-pkcs7-padding)가 있었습니다.
저 글을 읽어보면 알 수 있지만 PKCS#5는 PKCS#7의 subset이며, PKCS#5는 사실상 (triple)DES만 고려하고 나온 물건이라고 합니다.
즉, 우리가 찾아 헤매던 것은 PKCS#7이라는 것을, PKCS#7을 정의한 [RFC2315](https://www.ietf.org/rfc/rfc2315.txt)의 10.3 Note 2를 보면 알 수 있습니다.

>        2.   Some content-encryption algorithms assume the
>             input length is a multiple of k octets, where k > 1, and
>             let the application define a method for handling inputs
>             whose lengths are not a multiple of k octets. For such
>             algorithms, the method shall be to pad the input at the
>             trailing end with k - (l mod k) octets all having value k -
>             (l mod k), where l is the length of the input. In other
>             words, the input is padded at the trailing end with one of
>             the following strings:
>
>                      01 -- if l mod k = k-1
>                     02 02 -- if l mod k = k-2
>                                 .
>                                 .
>                                 .
>                   k k ... k k -- if l mod k = 0
>
>             The padding can be removed unambiguously since all input is
>             padded and no padding string is a suffix of another. This
>             padding method is well-defined if and only if k < 256;
>             methods for larger k are an open issue for further study.

혹시라도 PgCrypto로 encrypt된 내용을 decrypt하지 않고 가져온 뒤 DB가 아닌 다른 곳에서 decrypt할 것이라면 padding algorithm으로 PKCS#7을 사용하면 될 것입니다.
예를 들자면 Python의 `cryptography`는 padding 방법으로 `PKCS7`이라는 class를 지원합니다.
하지만 Oracle(DBMS)는 `DBMS_CRYPTO.PAD_PKCS5`만 존재합니다.
이런 차이점을 주의하면서 사용하면 될 것 같습니다.

---

별첨: `a % b % b == a % b` 증명에 대한 대화.
lifthrasiir님께 감사를 표합니다. :)

```
item4: lifthrasiir, a % b % b = a % b 임을 어떻게 증명할 수 있을까요
lifthrasiir: 1. for 0 <= x < y, x % y == x
lifthrasiir: 2. for 0 <= x, 0 < y, 0 <= x % y < y
lifthrasiir: 따라서 조합하면 증명 완료
lifthrasiir: 2에서 x % y를 1의 x 자리에 끼워 넣으면 되죠
```


PogstgreSQL support encryption with pycrypto, but they don't say about PKCS version. I post about correct version.

What is the PKCS algorithm version of PostgreSQL?

PostgreSQL의 PKCS Algorithm


[SQLAlchemy](http://www.sqlalchemy.org/)(이하 'SA'라고 줄여서 적음)를 사용하다가 궁금점이 생겼습니다.
PostgreSQL에는 [pgcrypto](http://www.postgresql.org/docs/9.4/static/pgcrypto.html)라고 하는 module이 있는데, 과연 여기서 정의된 함수를 SA에선 어떻게 사용할까 하는 점입니다.

제가 이런 의문을 가질 수 밖에 없는 이유는 SA는 ORM으로써 가능한 거의 모든 영역을 커버하려 하기 때문입니다.
예를 들면 아래와 같은 코드는 어떤 DBMS에서건 동작합니다.

```python
from sqlalchemy.sql.expression import func
session.query(func.now()).one()
```

불행히도 SQL은 DBMS별로 상당히 문법이 상이합니다.
현재 시간을 구하려면 SQLite에서는 `CURRENT_TIMESTAMP`를 사용해아하고, MySQL과 PgSQL에선 함수 `now()`를 사용해야 합니다.
자료형을 바꿀때는 SQLite에선 `cast('10' AS INTEGER)`꼴을 사용하는데 MySQL에선 살짝 다르게 `cast('10' AS SIGNED)`꼴을 씁니다.
PgSQL에선 `cast('10' AS int)`와 같이 쓸 수 있지만 `field_name::integer` 같은 형태로도 가능합니다.[^1]
하지만 SA를 사용하면 현재 시간 구하기, 자료형 바꾸기 모두 `func.now()`와 `func.cast('10', Integer)`로 충분히 가능합니다.
SA의 마법같은 부분이라고 할 수 있습니다.

자, 그럼 제가 쓰려고 하는 pgcrypto의 `encrypt_iv()`, `decrypt_iv()` 함수는 SA에서 어떻게 정의되어있을까요?
전 일단 [제가 하려고 하는 것과 가장 유사한 글](http://spoqa.github.io/2011/12/10/sqlalchemy-hybrid-attributes.html)을 참조해보았습니다.
저 글에서는 decryption을 `func.aes_decrypt(~~)` 이런 꼴로 사용하고 있었습니다.
그럼 SA에서는 decryption을 알고리즘별로 `ALGONAME_en/decrypt` 이렇게 함수를 정의해놓은 것일까요?
그렇다면 iv를 별도로 넣어줘야하는 케이스는 어떻게 했을까요?
저는 무턱대고 저걸 집어다 쓸 수 없다고 판단하고 SA 소스를 까보기로 했습니다.

[SA의 저장소는 사실 bitbucket에 있습니다.](https://bitbucket.org/zzzeek/sqlalchemy/)
하지만 난 구글링하면 나오는 [GitHub쪽 저장소](https://github.com/zzzeek/sqlalchemy)를 활용했습니다.
왜냐하면 GitHub은 저장소 내의 코드 내용을 검색할 수 있기 때문이죠.
가장 먼저 검색해본 것은 역시 먼저 봤던 `aes_decrypt`입니다.
[하지만 `aes_decrypt`로 검색해본 결과 아무것도 나오지 않았습니다.](https://github.com/zzzeek/sqlalchemy/search?utf8=%E2%9C%93&q=aes_decrypt)
그럼 아까 세웠던 가설처럼 `ALGONAME_en/decrypt` 형태로 조합하는건 아닐까 하는 생각이 들어 `crypt`로 검색해보았습니다.
[하지만 crypt 역시 나오지 않았습니다.](https://github.com/zzzeek/sqlalchemy/search?utf8=%E2%9C%93&q=crypt)

이쯤되면 `sqlalchemy.sql.expression.func`가 뭐하는 녀석인지 알아야할 필요가 생겼습니다.
바로 해당 파일을 열어보았죠.
[`func`의 정의는 `expression`이 아니라](https://github.com/zzzeek/sqlalchemy/blob/master/lib/sqlalchemy/sql/expression.py#L31) [같은 디렉토리의 `functions`에 있었습니다.](https://github.com/zzzeek/sqlalchemy/blob/master/lib/sqlalchemy/sql/functions.py#L280)

이것이 func의 정체입니다.

```python
func = _FunctionGenerator()
```

`_FunctionGenerator`는 바로 위에 정의된 클래스입니다.
그런데, 내부 구조가 좀 독특하게 되어있습니다.
우리는 보통 SA를 사용할때 `func.now()` 와 같은 형태로 사용합니다.
하지만 `_FunctionGenerator`에 `now`라는 메소드는 정의되어있지 않습니다.
대신 `__getattr__`과 `__call__`이 정의되어 있습니다.

`func.now`까지는 `__getattr__`의 범주에 속합니다.

```python
    def __getattr__(self, name):
        # passthru __ attributes; fixes pydoc
        if name.startswith('__'):
            try:
                return self.__dict__[name]
            except KeyError:
                raise AttributeError(name)

        elif name.endswith('_'):
            name = name[0:-1]
        f = _FunctionGenerator(**self.opts)
        f.__names = list(self.__names) + [name]
        return f
```

`__getattr__`은 내부적으로 (특수한 경우를 제외하고는) `_FunctionGenerator`를 만들어서 함수명(예를들어 `func.now`라면 `now`)을 내부에 저장하고 return합니다.

return되서 나온 값이 `_FunctionGenerator` 그 다음에(`func.now` 다음에) 나오는 `()`은 `__call__`의 범주에 속하게 됩니다.

```python
    def __call__(self, *c, **kwargs):
        o = self.opts.copy()
        o.update(kwargs)

        tokens = len(self.__names)

        if tokens == 2:
            package, fname = self.__names
        elif tokens == 1:
            package, fname = "_default", self.__names[0]
        else:
            package = None

        if package is not None:
            func = _registry[package].get(fname)
            if func is not None:
                return func(*c, **o)

        return Function(self.__names[-1],
                        packagenames=self.__names[0:-1], *c, **o)
```

이번엔 `Function`을 만들어서 return합니다.
첫 인자로 `self.__names[-1]`을 넣는 것을 볼 수 있는데, 이것은 `__getattr__`에서 맨 뒤에 함수 이름을 넣어서 그렇습니다.
즉, `func.now()`를 실행하면 `Function('now', ...)`과 같은 내용물이 남는 것입니다.

여기서부터는 상속의 늪인지라 소스를 뜯어봐도 이해가 되지 않았습니다.
일단 하나 확실한 것은 `Function`과 그 부모 클래스인 `FunctionElement`에도 `now`는 존재하지 않다는 것이죠.
더 봐도 알 수 없겠다 싶어서 접근 방법을 바꾸기로 했습니다.
왜냐하면 이런 식으로 소스를 까보다가는 SA의 전체 구현 명세를 다 파악해야할 가능성이 농후했기 때문입니다.
Python interactive shell을 사용하기로 했습니다.

```py
>>> from sqlalchemy import create_engine
>>> engine = create_engine('sqlite:///', echo=True)
>>> from sqlalchemy.orm import sessionmaker
>>> session = sessionmaker(bind=engine)()
>>> from sqlalchemy.sql.expression import func
```

일단 이렇게 해서 준비를 마쳤습니다.
`echo=True`옵션을 줘서 실제로 어떤 SQL이 실행되는지 볼 수 있도록 했습니다.
일단 가장 만만한 `func.now()`를 실행해보기로 했습니다.

```py
>>> session.query(func.now()).one()
2015-07-05 16:57:07,375 INFO sqlalchemy.engine.base.Engine SELECT CURRENT_TIMESTAMP AS now_1
2015-07-05 16:57:07,376 INFO sqlalchemy.engine.base.Engine ()
(datetime.datetime(2015, 7, 5, 7, 57, 7),)
```

`func.now()`가 `CURRENT_TIMESTAMP`로 바뀌었습니다.
이번엔 없을법한 것을 실행해보았습니다.

```py
>>> session.query(func.utcnow()).one()
2015-07-05 16:59:21,713 INFO sqlalchemy.engine.base.Engine SELECT utcnow() AS utcnow_1
2015-07-05 16:59:21,714 INFO sqlalchemy.engine.base.Engine ()
Traceback (most recent call last):
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1139, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/default.py", line 450, in do_execute
    cursor.execute(statement, parameters)
sqlite3.OperationalError: no such function: utcnow

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2473, in one
    ret = list(self)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2516, in __iter__
    return self._execute_and_instances(context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2531, in _execute_and_instances
    result = conn.execute(querycontext.statement, self._params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 914, in execute
    return meth(self, multiparams, params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/sql/elements.py", line 323, in _execute_on_connection
    return connection._execute_clauseelement(self, multiparams, params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1010, in _execute_clauseelement
    compiled_sql, distilled_params
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1146, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1341, in _handle_dbapi_exception
    exc_info
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/util/compat.py", line 188, in raise_from_cause
    reraise(type(exception), exception, tb=exc_tb, cause=exc_value)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/util/compat.py", line 181, in reraise
    raise value.with_traceback(tb)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1139, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/default.py", line 450, in do_execute
    cursor.execute(statement, parameters)
sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) no such function: utcnow [SQL: 'SELECT utcnow() AS utcnow_1']
```

실행한 SQL문을 들여다보면 `utcnow()`라고 바로 실행하려고 했음을 알 수 있습니다.
한가지만 더 실험해보기로 했습니다.
아예 있을리도 없는 함수에 이것저것 인자까지 줘보는 것입니다.

```py
>>> session.query(func.item4_coding(1, 2, 3, 4, 'blog')).one()
2015-07-05 17:03:54,575 INFO sqlalchemy.engine.base.Engine SELECT item4_coding(?, ?, ?, ?, ?) AS item4_coding_1
2015-07-05 17:03:54,575 INFO sqlalchemy.engine.base.Engine (1, 2, 3, 4, 'blog')
Traceback (most recent call last):
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1139, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/default.py", line 450, in do_execute
    cursor.execute(statement, parameters)
sqlite3.OperationalError: no such function: item4_coding

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2473, in one
    ret = list(self)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2516, in __iter__
    return self._execute_and_instances(context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/orm/query.py", line 2531, in _execute_and_instances
    result = conn.execute(querycontext.statement, self._params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 914, in execute
    return meth(self, multiparams, params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/sql/elements.py", line 323, in _execute_on_connection
    return connection._execute_clauseelement(self, multiparams, params)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1010, in _execute_clauseelement
    compiled_sql, distilled_params
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1146, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1341, in _handle_dbapi_exception
    exc_info
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/util/compat.py", line 188, in raise_from_cause
    reraise(type(exception), exception, tb=exc_tb, cause=exc_value)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/util/compat.py", line 181, in reraise
    raise value.with_traceback(tb)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/base.py", line 1139, in _execute_context
    context)
  File "/Users/item4/.virtualenvs/testenv/lib/python3.4/site-packages/sqlalchemy/engine/default.py", line 450, in do_execute
    cursor.execute(statement, parameters)
sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) no such function: item4_coding [SQL: 'SELECT item4_coding(?, ?, ?, ?, ?) AS item4_coding_1'] [parameters: (1, 2, 3, 4, 'blog')]
```

역시 바로 존재할 리 없는 `item4_coding()`이란 함수를 실행하려하다 에러가 났습니다.
여기서 알 수 있는 점은 SA가 실제로는 함수명을 전혀 검사하지 않는다는 점입니다.
그럼 `func.now()`는 어떻게 된 것일까요?
저는 이미 위의 실험에서 `func.now()`가 `CURRENT_TIMESTAMP`로 치환된다는 것을 확인했습니다.
[따라서 GitHub에 대고 `CURRENT_TIMESTAMP`로 바로 검색을 해보았습니다. 그리고 흥미로운 파일을 찾아냈죠.](https://github.com/zzzeek/sqlalchemy/blob/4e6ec9eef4e65c6efabae36b2307f2ad167977da/lib/sqlalchemy/dialects/sqlite/base.py#L795-L796)

이 파일은 바로 DBMS별 dialects중에 SQLite용입니다.
이 파일에는 `SQLiteCompiler`라는 이름으로 이런 메소드가 있었습니다.

```python
    def visit_now_func(self, fn, **kw):
        return "CURRENT_TIMESTAMP"
```

우리가 알고있던 동작명세와 일치하는 함수입니다.
차이점이라면 `now` 앞뒤로 `visit_`과 `_func`가 붙어있다는 점 정도입니다.
그 부분은 [소스에서 정말 열심히 훝어보면서 `visit_`과 `_func`라는 문자열이 있는 부분을 찾아보았더니 `SQLCompiler`라는 것이 나왔습니다.](https://github.com/zzzeek/sqlalchemy/blob/0766c80b9c02fdbad3203835ab850ad690f4c03b/lib/sqlalchemy/sql/compiler.py#L799)
`SQLCompiler`는 `SQLiteCompiler`의 부모클래스이기도 합니다.

```python
    def visit_function(self, func, add_to_result_map=None, **kwargs):
        if add_to_result_map is not None:
            add_to_result_map(
                func.name, func.name, (), func.type
            )

        disp = getattr(self, "visit_%s_func" % func.name.lower(), None)
        if disp:
            return disp(func, **kwargs)
        else:
            name = FUNCTIONS.get(func.__class__, func.name + "%(expr)s")
            return ".".join(list(func.packagenames) + [name]) % \
                {'expr': self.function_argspec(func, **kwargs)}
```

여기까지 살펴본 결과 더 이상 Internal한 요소를 모두 알지 않아도 대략적인 결론을 내릴 수 있었습니다.

1. `func.~~~`의 `~~~`는 함수명으로 저장됩니다.
2. DBMS별로 SQL을 처리하는 Compiler가 따로 있으며, 각각의 Compiler는 자신의 DBMS만의 특수한 경우를 예외처리합니다.
3. 각각의 Compiler에 예약되어있지 않은 경우 그냥 이름 그대로 함수로써 사용하려고 시도합니다. 이때, 정상 동작여부는 보장하지 않습니다. 따라서 오타를 주의해야 합니다.

이것으로 미루어볼때 제가 예제로 본 `aes_decrypt`를 naive하게 쓰는 것은 MySQL에서만 될 것입니다.
MySQL에서도 함수 사용법이 바뀌면 (버전이 올라간다던가 해서) 동작하지 않을것입니다.
나는 PgSQL에서 사용하는 방법이 필요한데, 혹시라도 MySQL에서 돌려야하는 상황이 온다면 대안이 필요할 것입니다.
이에 대한 문서가 별로 많지 않던데, 실제로 구현을 해보고 테스트해보고 난 뒤 포스팅할 예정입니다.

[^1]: field에 null이 있는 경우엔 [문제가 더 심각해집니다.](http://stackoverflow.com/questions/10518258/typecast-string-to-integer-postgres) `ifnull(fieldname, '')::integer`같은 형태로 써야합니다.


About internal implementation of sqlalchemy.sql.expression.func

item4 dev story

Posts