Clojureで行こう

Play Framework 2.0 と JSON ライブラリ Jerksonについて調べてみました。

2011-12-07T11:55:00.003+09:00

この記事はPlay! framework Advent Calendar 2011 jp #play_ja
の7日目です。
勢いで参加してみたものの、ネタが見つからず困っていたところ、@mumoshu さんのつぶやきが目にとまりました。

mumoshu この２日間のPlay 2.0は、Scala向けのJSON APIが変更されたり、Actionの合成方法がドキュメントにそった形になった。JSONの方は、使うライブラリがsjsonからJerksonへ変更。Jerksonをベースに、sjsonのようなAPIを実装している。 04 Dec 2011 from Twitter for Mac

-- this quote was brought to you by quoteurl

Jerksonというライブラリは全く知りませんでした。
調度良いのでこのJerksonについて調べたことを書こうと思います。
（Play20のplay.api.jsonは、現在絶賛開発中といった感じなので、これからしばらく不安定な様子です。
おそらくここに書くこともすぐに古くなると思いますのでご了承ください。）

Jerksonって？

Jerksonは、Java JSON-processorであるところのJacksonの、Scala wrapperです。

これまで候補であったsjsonについては@eed3si9n さんの翻訳記事、
sjson: Scala の型クラスによる JSON シリアライゼーションに詳しく書かれています。sjsonは、implicit parameterによる型クラスエミュレートを使った便利なライブラリです。sjsonでは、型クラスを使うことでシリアライズ、デシリアライズプロトコルのカスタマイズ手段を提供しています。
sjsonからJackson/Jerksonに移行した理由はわかりませんが、ScalaとJavaを両方サポートするPlay!ではJavaベースのJacksonとそのScala wrapperというのが都合が良かったのかもしれません。
play.api.jsonでは、このJerksonに、sjsonライクなシリアライズ／デシリアライズプロトコルをかぶせた形になっています。
apiとしては、まずJsValue型とStringの相互変換をする２つの関数が用意されています。


def parseJson(input: String): JsValue  = JerksonJson.parse[JsValue](input) 
def stringify(json: JsValue): String = JerksonJson.generate(json)

parseJsonは、StringからJsValueへ、stringfyはその逆で、JsValueをStringにします。
これらの中身はJerksonにそのままお任せで、特にカスタマイズも想定されていますん。
JsValue という型が中間表現になっていて、任意のScalaオブジェクトをJsValueにしてからStringにしたり、
JSON文字列をパースしてまずはJsValueにしてから、任意のScalaオブジェクトに変換することになります。
ちなみにJsValueという型は次のような構成になっています。


sealed trait JsValue {...}
case object JsNull extends JsValue {...}
case class JsUndefined(error: String) extends JsValue {...}
case class JsBoolean(override val value: Boolean) extends JsValue
case class JsNumber(override val value: BigDecimal) extends JsValue
case class JsString(override val value: String) extends JsValue
case class JsArray(override val value: List[JsValue]) extends JsValue {...}
case class JsObject(override val value: Map[String, JsValue]) extends JsValue  {...}

ベタにJSONのデータ構造そのままですね。
それぞれcase classなので、このままでも使うことができますが、ちょっと不便です。
そこで、任意の型との相互変換を行う関数として、次の２つが用意されています。


def toJson[T](o: T)(implicit tjs: Writes[T]): JsValue = tjs.writes(o)
def fromJson[T](json: JsValue)(implicit fjs: Reads[T]): T = fjs.reads(o)

Writes[T]がT型からJsValueへの変換を、
Reads[T]がJsValueからT型への変換を提供するオブジェクトの型になっています。
それぞれimplicitとなっているので、


import play.api.json.Reads._
import play.api.json.Writes._

などとしておけば、


assert (toJson(Map("a"->2)).toString =="""{"a":2.0}""")
assert (fromJson[Int](parseJson("1")) == 1)
assert (fromJson[Map[String,SortedSet[Int]]](parseJson("""{"a":[1,5,3]}""")) == Map("a" -> SortedSet(1,3,5)))
assert (fromJson[Map[String,List[Int]]](parseJson("""{"a":[1,5,3]}""")) == Map("a" -> List(1,5,3)))

といった形で、よくある感じの型にはデフォルトで変換プロトコルが提供されていて、
簡単に使うことができます。
ちなみにWrites[T] とReads[T]はこんな感じです。


trait Writes[T] {
  def writes(o: T): JsValue                                                                                                                                                                         
}
trait Reads[T] {
  def reads(json: JsValue): T                                                                                                                                                                       
}

（Writes Readsの他に次のようなFormatという型も用意されています。おそらく今後これを実装したobjectが提供されるんだと思います。


trait Format[T] extends Writes[T] with Reads[T]

）

カスタム変換プロトコル

次に自分の好きな変換を提供する方法について考えてみます。
まずは、Reads[T]の実装をみてみます。
シンプルな例としてReads[Boolean]は次のようになっています。


implicit object BooleanReads extends Reads[Boolean] {
  def reads(json: JsValue) = json match {
    case JsBoolean(b) => b
    case _ => throw new RuntimeException("Boolean expected")
  }
}

def reads(json: JsValue):Boolean
な型のメソッドを持つReads[Boolean]なオブジェクトをimplicitで提供するだけですね。
変換したい型が、List[T]などのパラメータ化された型の場合はもう少し複雑になります。
List[Int]、List[Boolean]などについて個別にReads[List[Int]]などを用意していけば、
Reads[Boolean]と同じ形に書けますが、これだとList[List[List[Int]]]などのネストを考えると
事前にすべて用意する訳にはいかなそうです。
そこで、Tがなにかはわからないけれど、T（例えばIntだったりする何か）について変換する方法を
教えてくれれば、List[T]の変換方法を教えましょう、という形の関数を書くことになります。
Tの変換方法とはつまりReads[T]型のオブジェクトで、
List[T]の変換方法とはReads[List[T]]型のオブジェクトです。
なので型でいうと、Reads[T]型のオブジェクトを受け取って、Reads[List[T]]型のオブジェクトを返す関数を
書くことになります。実際のソースの該当部分は次のようになります。


implicit def listReads[T](implicit fmt: Reads[T]): Reads[List[T]] = new Reads[List[T]] {
  def reads(json: JsValue) = json match {
    case JsArray(ts) => ts.map(t => fromJson(t)(fmt))
    case _ => throw new RuntimeException("List expected")
  }
}

ここで、implicit fmt: Reads[T]と、Reads[T]型の引数についてもimplicitが指定してあるので、
例えば先ほどのimplicit object BooleanReads extends Reads[Boolean]
などが提供されていれば、listReadsにBooleanReadsが暗黙に自動的に供給されて、
Reads[List[Boolean]] も自動的に供給されることになります。
この仕組みを使って、ここでは試しにReads[Either[A, B]]な変換方法の提供を考えてみたいと思います。
JSONは基本動的型付けなので、[1, 2, null]のように、
ひとつの配列の中に様々な型の値が一緒に入っていることがあります。
連想配列であれば、違うキーに対しては、むしろ別の型の値が入っていることの方が普通でしょう。
例えば、{"name":"milk", "price":150}のように。
こういったものでもEither型への変換ができればすこしだけ便利かもしれません。
Either[A,B]は型パラメータを二つとるので、変換方法もReads[A]とReads[B]の２種類が必要です。
fromJsonを使って型の変換に失敗したときは例外が投げられるので、それをキャッチして
分岐してもいいのですが、成功したときはSome[A]、変換に失敗したときなNoneを返してくれる
便利なasOptメソッドがあるのでここではそれを使ってみました。


implicit def eitherReads[A,B](implicit fmtA: Reads[A], fmtB: Reads[B]):Reads[Either[A, B]] =
  new Reads[Either[A, B]] {
      def reads(json: JsValue) =
          json.asOpt[A](fmtA) match {
             case Some(a) => Left(a)
             case None => Right(fromJson[B](json)(fmtB))
           }
       }


assert (fromJson[Either[String,Int]](json.parseJson("""1""")) == Right(1))
assert (fromJson[Either[String,Int]](json.parseJson(""""a"""")) == Left("a"))
assert (fromJson[List[Either[Either[Boolean,String],Int]]](json.parseJson("""["a",true, 5]""")) 
              ==  List(Left(Right("a")), Left(Left(true)), Right(5.0)))

これでちょっとは便利になりましたが、Either型をたくさん使うと
どこかでパターンマッチをたくさん書くことになって、JsValueに対して
パターンマッチを書いていくのとあまり変わらないことになってしまいます。
なにより型の混ざった配列ならともかく、
{"name":"milk", "price":150}のような連想配列は
Map[String, Either[String,Int]]
に変換するのではなく、
case class Hoge(name:String, price:Int)
のような何らかのクラスに変換したいのが普通でしょう。
もちろん特定のcaseクラスへの変換を記述することはそれほど大変なことではありませんが、
case クラスがたくさんある場合は、ちょっと面倒そうです。
そんな時のために、sjsonでは、任意のcase クラスへの変換プロトコルを簡単に提供するための
便利な関数が用意されています。Scalaでは可変長の型引数はサポートされていないので、
case クラスのメンバの数に応じて、asProduct1、asProduct2、asProduct3...
といったメソッドが用意されています。
sjsonのソースでは、テンプレートを使ってこれらの定義が自動生成していますが、
ここではplay.api.json用に、asProduct3だけをポーティングしてみたいと思います。
まず、asProduct3のシグネチャは次のようになります。


def asProduct3[S, T1, T2, T3]
       (f1: String, f2: String, f3: String)
       (apply : (T1, T2, T3) => S)
       (unapply : S => Product3[T1, T2, T3])
       (implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3])
       : Format[S]

まず、型パラメータの[S, T1, T2, T3] です。
ひとつめのSは、変換対象のcase クラスです。
T1,T2,T3はそれぞれ、caseクラスのメンバ変数の型になります。
最初の引数、
(f1: String, f2: String, f3: String)
は、メンバ変数に体操するJSONでのキーになります。
メンバ変数の名前と同じものになることも多いでしょう。
次の二つの引数 applyとunapplyは、
(apply : (T1, T2, T3) => S)
(unapply : S => Product3[T1, T2, T3])
caseクラスのコンパニオンオブジェクトのapply unapplyメソッド
を受け取ります。
最後に、各メンバ変数の型ごとにReads[T1]やWrites[T1]を供給するために
Format[T1]をimplicitに受け取ります。

たとえば、case class Hoge(name:String, price:Int, flag:Boolean)
を、{"name":"...", "price":1234, "flag":true}に変換するのであれば、

asProduct3[Hoge, String, Int, Boolean]
("name", "price", "flag")
(Hoge.apply)
(Hoge.unapply)
といった引数を渡すだけで、
Format[Hoge]の実装を得ることができます。
asProduct3の実装は次のような感じになります。


def asProduct3[S, T1, T2, T3](f1: String, f2: String, f3: String)
                             (apply : (T1, T2, T3) => S)
                             (unapply : S => Product3[T1, T2, T3])
                             (implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3])
  = new Format[S]{
      def writes(s: S) = {
        val product = unapply(s)
        JsObject(
          Map(
          (f1, toJson(product._1)),
          (f2, toJson(product._2)),
          (f3, toJson(product._3))
        ))
       }
       def reads(js: JsValue) = js match {
         case JsObject(m) =>
           apply(
             fromJson[T1](m(f1)),
             fromJson[T2](m(f2)),
             fromJson[T3](m(f3))
            )
         case _ => throw new RuntimeException("object expected")
   }
}

これを使えば、例えば次のようなcase クラスに対して、


case class Shop(store: String, item: String, price: Int)

次のように変換プロトコルを簡単に用意することができます。


object ShopProtocol {
  import DefaultFormat._
  implicit val ShopFormat: Format[Shop] =
    asProduct3("store", "item", "price")(Shop)(Shop.unapply(_).get)
}

詳しくは、sjsonのgithubの該当部分をご覧ください。
https://github.com/debasishg/sjson/blob/master/src/main/scala/sjson/json/Generic.scala

以上です。
これを書いている間に日が変わってしまいました！ゴメンナサイ！！
次回12月8日は@hagikuratakeshiさんです。

よろしくお願いします！！

SQLAlchemyのモデルクラス用のFlaskコンバータを作ってみる

2010-12-11T23:59:00.006+09:00

最近、PythonのWebフレームワークの中では、軽量級のFlaskをよく使っています。
Flaskは、wsgiツールキット的なWerkzeugを基盤に構築されたフレームワークです。
Flaskではroutingの仕組みは、Werkzeugのものをほぼそのまま使い、
関数を簡単にコントローラとして公開できるようなデコレータが用意されています。
これはたとえば以下のように使います。


@app.route("/post/<int:post_id>")
def show_post(post_id):
   return "hello"

<int:post_id>というところに注目してください。
この定義により、"/post/10"や"/post/5"のようなURLにマッチし、
show_post関数の引数post_idに、マッチした部分をintに変換し
10や5といった値がわたってくる事になります。

この<int:hoge>の部分は、Converterと呼ばれる仕組みで自作することができるようになっています。
今回は、SQLAlchemyとからめて、idを受け取って、特定のモデルクラスのインスタンスを
抽出するようなConverterを書いてみたいと思います。
モチベーションとしては、以下のようにIDをintとして受け取って、
そのidでインスタンスを検索し、なかったら404にするような操作を、


@app.route("/post/<int:post_id>")
def show_post(post_id):
   post = Post.query.get(post_id)
   if not post:
       raise werkzeug.exceptions.NotFound()
   return post.hoge()

次のように、モデルと同名のコンバータを指定する事で、
自動でIDの文字列からインスタンスをfetchして引数として渡し、
もし該当IDがなければ、自動で404としてくれれば、便利かなという感じです。


@app.route("/post") # idが該当しなければ404
def show_post(post):
   return post.hoge()

まず準備として、FlaskアプリとSQLAlchemyの初期化を行います。


from flask import Flask, request, url_for, redirect
from flaskext.sqlalchemy import SQLAlchemy
from sqlalchemy import Table, Column, Integer, Unicode
from sqlalchemy.orm import mapper
from werkzeug.routing import IntegerConverter, ValidationError

app = Flask(__name__)

app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db"
db = SQLAlchemy(app)

アプリやデータベースの準備ができたら、
早速コンバータのベースクラスを定義してみましょう。


class BaseModelConverter(IntegerConverter):
   def __init__(self, map):
       super(BaseModelConverter, self).__init__(map)

   def to_python(self, value):
       id_ = super(BaseModelConverter, self).to_python(value)
       obj = self.model.query.get(id_)
       if not obj:
           raise ValidationError()
       return obj

   def to_url(self, value):
       return str(value.id)

IntegerConverterを継承するので、正規表現的に\d+にマッチするかのチェックが
まず行われます。
to_pythonメソッドでは、valueつまりマッチした部分の文字列を受け取ります。
IntegerConverter.to_pythonに渡し、int値を得ます。（この時点で失敗すればその中でValidationErrorが投げられます）
このint値、つまりIDをもとにself.model.query.get(id_)により、インスタンスを取得し、
Noneが得られた場合はValidationErrorとします。
to_urlメソッドの方は、その逆に、インスタンスを受けて、そのidをstrにしたものを返すだけです。

そして、モデルを定義するたびにコンバータを追加していると手間なので、
特定のベースモデルクラスを継承したモデルを定義すると自動で同名のコンバータを
追加するようなベースクラスを用意します。
ベースクラスとそのメタクラスの定義は次のようになります。



class BaseModelType(type):
   def __init__(cls, name, bases, attrs):
       super(BaseModelType, cls).__init__(name, bases, attrs)
       if name == 'BaseModel':
           return
       conv = type(name + "Converter", (BaseModelConverter,), dict(model=cls))
       app.url_map.converters[name] = conv

class BaseModel(object):
   __metaclass__ = BaseModelType

BaseModelType.__init__の中では、
BaseModelのコンバータは不要なので、とりあえず名前で
BaseModelかどうかのチェックを行います。
そうでなければ、そのモデルの名前 + "Converter"
たとえば UserConverterのような名前の、BaseModelConverterを継承したクラスを生成します。
これは、


class UserConverter(BaseModelCOnverter):
   model = User

と同等です。
そして得られたコンバータクラスを、app.url_map.convertersに、モデルと同じ名前で登録します。
BaseModelは、BaseModelTypeをメタクラスとして持ち後は空のクラスです。

ではこれをつかって試しにUserクラスを定義します。


user_table = Table(
   "user_table", db.metadata,
   Column('id', Integer, primary_key=True),
   Column('name', Unicode(100)),
)

class User(BaseModel):
   query = db.session.query_property()
   def __init__(self, name):
       self.name = name

mapper(User, user_table)

とりあえず、上記のように、idとnameだけを持つモデルを定義してみました。
あとはこれをつかったコントローラを書きます。
今回は紙面の都合上テンプレートの使用は省略して
直接文字列を返しておきます。


@app.route("/detail/<User:user>", methods=('GET',))
def detail(user):
    return """
    <html><body>
    <h1>%s</h1>
    </body></html>
    """ % user.name

もう、説明することがないくらいシンプルなコントローラです。
あとは、Userインスタンスを登録し、そのリストを一覧でだせるようにしましょう。


@app.route("/", methods=('GET',))
def users():
    userlist = "".join(
        '<a href="http://www.blogger.com/%s">%s</a>' % (
            url_for('detail', user=user), user.name)
        for user in User.query.all())
    return """
    <html><body>
    %s
    <hr />
    <form method="post" action="/">
    <input type="text" name="name">
    <input type="submit">
    </form>
    </body></html>
    """ % userlist

@app.route("/", methods=('POST',))
def add_user():
   user = User(request.form['name'])
   db.session.add(user)
   db.session.commit()
   return redirect(url_for('users'))

url_for('detail', user=user)の部分で、UserConverter.to_urlが内部で呼び出され、
適切なURL、たとえば/detail/1　といったURLが生成されることになります。

これで準備はととのいました。
あとは、実行するだけです。


if __name__ == "__main__":
   db.metadata.create_all(db.engine)
   app.debug=True
   app.run(host="127.0.0.1",port=8000)

と最後にかいて、ファイル全体をmain.pyなどの適当な名前で保存し、
python main.py
とすればサーバが立ち上がります。
適当にユーザを追加して動作を確認しましょう！

今回はモデルのIDをマッチする単純なものでしたが、
id以外のカラムにマッチしたり、難読化したidにマッチしたり、
制限時間付きのhmacトークンを埋め込むURLを生成したりといったことが
コンバータの追加で行う事ができます。ちょっとしたことではありますが、
コンバータで抽出、整合性のチェックを行い、失敗すれば404にしてくれるのは
地味に便利だったりします。
皆さんもFlaskやWerkzeugを使って便利なコンバータを使って、
すてきな Python Web FWライフを！
ということでつぎは、@r_rudi　にバトンを渡したいと思います。よろしく！＞@r_rudi

zope.sqlalchemyの紹介

2009-12-16T19:24:00.002+09:00

中西さんよりZope/Ploneアドベントカレンダーのバトンを頂戴したので、Zope/Ploneネタを書いて16日目を担当したいと思います。

普段の仕事ではZope/PloneよりもSQLAlchemyなどを使いつつRDBMSを使用するようなフレームワークを使うことの方が多いです。

どんなネタにしようかとすこし悩みましたが、Zope/PloneからSQLAlchemy越しにRDBMSにアクセスする方法について調べてみました。

Zopeは自前のオブジェクトデータベースZODBを持っているのでZope/PloneからRDBMSを使用する機会はあまりありませんが、既存のデータベースとやりとりが必要になることは、たまにあります。

ZopeからRDBMSを操作する方法としては、

Z SQL Method

を使用するが昔からあって、

select * from products where id=<dtml-sqlvar type="string">

このような感じで使用するようですが、ちょっと古い感じがしないでもないです。

現在PythonでSQLとなれば、

The Python SQL Toolkit and Object Relational Mapperであるところの

SQLAlchemyを使うのが一般的です。

ということで、zope.sqlalchemyを使う方法を調べてみました。

zope.sqlalchemyは、"Minimal Zope/SQLAlchemy transaction integration"ということで

ZopeのトランザクションとSQLAlchemyのトランザクションを統合してくれる

ツールのようで、その際、きちんと二相コミットもしてくれるようです。

zope.sqlalchemyの守備範囲は、トランザクションに関してだけで、データベースエンジンやデータモデルの記述については特別なサポートはありません。

つまり、SQLAlchemyの作法に則って、DBエンジンやモデルについての記述を行うことはできるけれども、ZMIからデータベースエンジンの設定を行ったり、zcmlで定義したり、Zopeのオブジェクトモデルとマッピングしたり、といった機能はなく、あくまでトランザクションの統合機能だけが提供されます。

>>> from sqlalchemy import create_engine
>>> engine = create_engine("mysql://hoge", convert_unicode=True)
>>> from sqlalchemy.orm import scoped_session, sessionmaker]
>>> from zope.sqlalchemy import ZopeTransactionExtension
>>> Session = scoped_session(sessionmaker(bind=engine,
...     twophase=True, extension=ZopeTransactionExtension()))
>>> session = Session()
>>> session.add(Hoge(name='fuga'))
>>> session.query(Hoge).all()
[]
>>> import transaction
>>> transaction.commit()

とこんな感じの使い方になるようです。
（詳しくはzope.sqlalchemyを参照してください。）
ポイントは、

sessionmaker(bind=engine,
twophase=True, extension=ZopeTransactionExtension())

の部分と

>>> import transaction
>>> transaction.commit()

のところです。

コードの説明に入るまえに、そもそもなぜトランザクションの統合が必要になるか、ということについて簡単に説明します。

Wikipediaのトランザクションの項によると、
"トランザクション (transaction) とは、分ける事の出来ない一連の情報処理の単位である"とあります。
つまりひとつのトランザクションに含まれる処理であれば、全部が成功もしくは全部が失敗のどちらかになるべきで、一部が失敗して一部が成功した、といった状態になったら困るわけです。これを実現するために、ひとつの
トランザクション処理の途中で、なんらかの不都合が発生した場合、そこまでの処理をすべてなかったことにするロールバックや、すべての処理が成功した段階で、変更結果を永続化させるコミットの機能がZODBやRDBMSにより提供されます。

ZopeのZODBはトランザクションをサポートしており、作法に則ったやり方でZODBにアクセスすれば、処理の途中で例外が発生した場合ロールバックされ、一貫性が保たれます。
しかし、そこでロールバックされるのは当然ZODBに対する書き込み操作のみで、もし直接外部のRDBMSに対して書き込みを行っていた場合、その処理まで自動でロールバックされるわけではありません。すると、Zope/Ploneとしては処理が途中で失敗したのでロールバックを行い、ZODBの中身的には変更が無かったことになっているのに、外部のRDBMS には処理が成功したかのように変更が書き込まれてしまう、といった結果になる可能性があります。多くの場合において、これは望んだ結果ではないでしょう。
これを防ぐには、ZODBとRDBMSに対するふたつのトランザクションを統合し、ZODBに対する処理とRDBMSに対する処理が、両方成功するか、両方失敗するか、どちらかであるようにする必要があります。

これを実現する中核となるのが、zope.sqlalchemy.ZopeTransactionExtensionです。これはSQLAlchemyの
extending-sessionという機能を利用したもので、
sqlalchemy.orm.interfaces.SessionExtensionを継承（or実装。ここらへんはPythonなので微妙なところですね。）したクラスです。このクラスを使用することにより、zope.sqlalchemyはセッションの開始や、セッションの中でオブジェクトの追加や変更、削除などをフックすることができます。
でもって、セッションの開始でTwoPhaseSessionDataManagerインスタンスを作成し、zope_transaction.get().join(TwoPhaseSessionDataManager(session, state))
のような感じでzopeのトランザクションに結びつけます。
そして、SQLAlchemyのセッションでオブジェクトの変更などをフックして、状態を初期状態のSTATUS_ACTIVEからSTATUS_CHANGEDに変更します。
そんでもって

>>> import transaction
>>> transaction.commit()

によりzopeのトランザクションがコミットされた場合は、TwoPhaseSessionDataManagerのメソッドが呼び出され、
もし状態がSTATUS_CHANGEDになっていれば、二相コミットを行います。

STATUS_ACTIVE/STATUS_CHANGEDと、2相コミットに関して補足します。

2相コミットとは、複数のデータベースが存在する時に、各トランザクションを統合して、全体として成功／失敗のどちらかにするための技術です。ちょっと説明が適当なので、
詳しくは
Wikipedia:"2相コミット"を参照してください。
例えば、データベースAとBがあった場合、よくありそうな問題としては、全部の処理がうまくいったので、
まずAにコミットして成功し、つぎにBに対してコミットを行おうとしたら、コミットに失敗してしまった、という状況です。
これを防ぐために2相コミットでは、トランザクションのコミットしようとするとき、
参加しているデータベースに対して、コミットが可能であるか、まず全員に質問します。ここで、全員から同意が得られれば、全体をあらためてコミットします。逆に、どれかひとつでも同意が得られなかった場合は、全体をロールバックさせます。この2相コミットを使用すれば、DBMSが落ちる、DBMSとのネットワークが切れるなどの事態が肝心なタイミングで発生しなければ、全体の一貫性を保つことができます。
この2相コミットは、それなりに面倒な処理です。RDBMSの方に書き込みを行わなかった場合、そもそも2相コミットを行う必要がありません。このためにzope.sqlalchemyでは、SQLAlchemyのセッションに変更操作を行ったかどうかを、STATUS_ACTIVE/STATUS_CHANGEDという状態により管理し、zopeのtransaction.commit()時にSTATUS_ACTIVEのままであれば2相コミットを省略するような動きになっているようです。
STATUS_ACTIVE/STATUS_CHANGEDの状態は、sqlalchemy.orm.interfaces.SessionExtensionのafter_bulk_updateメソッドなどが呼び出されるタイミングで、STATUS_CHANGEDに変更されます。
このフックメソッドは、次のようにORMを通さないでSQLが発行された場合は呼び出されません。
（よびだしてくれればいいような気がしますが。）

>>> conn = session.connection()
>>> conn.execute(update_expression)

この問題を防ぐため、このような場合には、つぎのように明示的にSTATUS_CHANGEDをセットします。

>>> from zope.sqlalchemy import mark_changed
>>> mark_changed(session)

<追記 2009-12-18>

sessionmakerの作成の際に、twophase=Falseにしておけば、2相コミットをせずに

動いてくれます。当然不整合が起こる可能性は高くなりますが。

あと、twophase=Trueの場合は、当然ですがRDBMS側でも2相コミットが可能な設定になっている必要があります。

ということで、ということで、次のバトンは昔からブログでお世話になっているPythonの大先輩のnakagamiさんにお願いします。

2009-12-06T22:56:00.001+09:00

InfoQ ClojarsとLeiningenを使ったClojure向け自動ライブラリ依存関係管理

PythonのPYPI、easy_install/pipにあたるもののようだ。

slime + swank-clojureの続き

2009-12-06T18:02:00.003+09:00

slime + swank-clojureが、やっぱり調子が悪く、
どうもClojure1.1との組み合わせの問題のようなので
http://github.com/stuarthalloway/swank-clojure/tree/clojure-1.1
のswank-clojureを使ったらうまく動いた。

(追記)
結局
http://github.com/technomancy/swank-clojure/tree/clojure-1.1
の方に変更した。

slime + swank-clojureが動かない

2009-12-05T09:56:00.004+09:00

Clojure with Emacs and Slime/Swank on Ubuntuを参考にemacs + slime + swank-clojureでプログラミングしてるのだけれど、
最近のslimeとswank-clojureの組み合わせがこける。
SLIME REPL broken
を参考に、

"/home/hokari/opt/swank-clojure/src/main/clojure/swank/core/protocol.clj"
を

@@ -4,6 +4,20 @@

;; Read forms

+ (def #^{:private true}

+ *percent-re* #"%")

+

+(defn- fix-percent

+ "Replace double colons with a /."

+ ([text] (.replaceAll (re-matcher *percent-re* text) "?")))

+

+(def #^{:private true}

+ *double-colon-re* #"::")

+

+(defn- fix-double-colon
+ "Replace double colons with a /."

+ ([text] (.replaceAll (re-matcher *double-colon-re* text) "/")))

+

(def #^{:private true}

*namespace-re* #"(^\(:emacs-rex \([a-zA-Z][a-zA-Z0-9]+):")

(defn- fix-namespace

@@ -50,7 +64,7 @@

([#^java.io.Reader reader]

(let [len (Integer/parseInt (read-chars reader 6 read-fail-exception) 16)

msg (read-chars reader len read-fail-exception)

- form (read-string (fix-namespace msg))]

+ form (read-string (fix-namespace (fix-double-colon (fix-percent msg))))]

(if (seq? form)

(deep-replace {'t true} form)

form))))

のようなかんじにしたら動いた。
Common LispとClojureで"%"や"::"の意味とか許可/不許可が違うせい、
ということみたい。

ClojureのvectorやlistをJavaの配列にキャストする方法

2009-11-16T19:01:00.003+09:00

ClojureからJavaのメソッドを呼び出すときなどに、
ClojureのvectorからString[]やint[]などにキャストする必要がある場合、
to-arrayやinto-arrayを使うとキャストできる。


user> (to-array ["a" "hello"])
#                                                                                                                                        
user> (into-array ["a" "hello"])
#                                                                                                                                        
user> (into-array String ["a" "hello"])
#                                                                                                                                        
user> (into-array Number [1 1.2])
#                                                                                                                                       
user> (into-array [1 2])
#                                                                                                                                      
user> (into-array [1 1.2]) ;これはエラーに
; Evaluation aborted.

UsedのThinkpad X60s購入

2009-06-05T00:15:00.002+09:00

UsedのThinkpad X60sを￥39,800で購入しました。ちなみに英語キーボードです。
Ubuntuを入れて快調です。メモリは２G追加。
インストールはUSBメモリからで、ひっかかることもなく
とても簡単にできました。無線LANもデフォルトで使用できました。
右パームレスト部分が無線LANカードの発熱のために熱くなりますが、
これは仕様なようです。無線OFFにしておくと熱くならなかったし、
無線もともと使わない予定なので問題なし。
久方ぶりにマイノートPCを手に入れ感無量。
半年くらいしたらSSDにしたいなぁと妄想は膨らむ。

JavaOne 2009 Script Bowl

2009-05-31T19:54:00.004+09:00

JavaOne 2009では、去年のJavaOne 2008に引き続きScript Bowlのセッションがあるようです。
Script Bowlでは、JavaVM上のスクリプト言語同士でプログラミング対決をしたり、
言語の特長を紹介したりするようです。
去年は、Scala,Groovy,JRuby, Jythonだったのですが、
今年はこれにClojureが加わって5つの言語で対決するようです。
JavaVM上のスクリプト言語は、他にも山ほどあるわけで、
JavaOneで5つめに選ばれたってことは、けっこう注目度がたかいということでしょうか。
これをきっかけにさらに盛り上がるといいなぁ。

Clojure勉強の進捗

2009-05-19T22:26:00.003+09:00

1.Clojureでマクロ
マクロの練習に、パターンマッチングのマクロを書いた。
マクロの基本的な書き方や、mapやvector、sequenceの基本もわかってきた。

gitの使い方を覚えて、antの使い方の基礎を覚えたら、
githubにのせてみたい。

2.Clojureでモナド
Clojure.contrib.monadsの使い方を下記の解説をみて覚える。
Monads in Clojure
A monad tutorial for Clojure programmers (part 1)
part 2
part 3
part 4

http://stefan-klinger.de/
のところにある
The Haskell Programmer's Guide to the IO Monad — Don't Panic.
をもう一度読む。
Arrow syntax
8.10. アロー記法
も読んでArrowも理解したい。

3.その他
軽くJavaの復習。antやJDEEなども。
あとConcurrent-Programming-Java-TM-Principles
を注文したのできたら読む。

LWGL - Lightweight Java Game Library
というのを見つけた。よさそう。

Tokyo CabinetをUbuntuにインストール

2009-05-10T18:03:00.012+09:00

Tokyo Cabinet
Tokyo CabinetはHirabayashi Mikio 氏により新しく実装された高速なDBMです。

DBMというのは、Database Managerの略で、非常にシンプルなキー：バリュー型の
データベースです。プログラミングでいうところのハッシュマップや連想配列、辞書と同じような機能を、ファイル上に永続化して使用できるというようなものです。
Berkeley DBなどが有名です。

Tokyo Cabinetは、とても新しく実装されたDBMで、
高速な処理や非常に大きいデータベースファイルを扱えるなどのすぐれた
特徴を持ち、Java,Perl,Ruby,Lua用のAPIが公式に用意されています。

ClojureでオレオレDBMSを実装するためのバックエンドとして使いたいと思っているので、
今回はまず、UbuntuにTokyo CabinetとJava APIをインストールします。

sudo apt-get update
wget http://tokyocabinet.sourceforge.net/tokyocabinet-1.4.20.tar.gz
sudo apt-get install build-essential
sudo apt-get install zlib1g-dev 
sudo apt-get install libbz2-dev

wget http://tokyocabinet.sourceforge.net/tokyocabinet-1.4.20.tar.gz
tar xzvf tokyocabinet-1.4.20.tar.gz
cd tokyocabinet-1.4.20
export CPPFLAGS="-I/usr/lib/jvm/java-6-openjdk/include/"
export JAVA_HOME=/usr/lib/jvm/java-6-openjdk
export PATH=$JAVA_HOME/bin:$PATH

./configure
make

ここで前回インストールしたPacoを使用して

sudo make install

のかわりに、

sudo paco -D make install

としてインストールしてみた。
つぎにJava用APIをインストール。

wget http://tokyocabinet.sourceforge.net/javapkg/tokyocabinet-java-1.18.tar.gz
tar xzvf tokyocabinet-java-1.18.tar.gz
cd tokyocabinet-java-1.18
./configure
make
make check
sudo paco -D make install

http://tokyocabinet.sourceforge.net/javadoc/
にあるサンプルを実行。

import tokyocabinet.*;
% cat TCHDBEX.java
import tokyocabinet.*;

public class TCHDBEX {
    public static void main(String[] args){
        HDB hdb = new HDB();
        if(!hdb.open("casket.tch", HDB.OWRITER | HDB.OCREAT)){
            int ecode = hdb.ecode();
            System.err.println("open error: " + hdb.errmsg(ecode));
        }
        if(!hdb.put("foo", "hop") ||
           !hdb.put("bar", "step") ||
           !hdb.put("baz", "jump")){
            int ecode = hdb.ecode();
            System.err.println("put error: " + hdb.errmsg(ecode));
        }
        String value = hdb.get("foo");
        if(value != null){
            System.out.println(value);
        } else {
            int ecode = hdb.ecode();
            System.err.println("get error: " + hdb.errmsg(ecode));
        }
        hdb.iterinit();
        String key;
        while((key = hdb.iternext2()) != null){
            value = hdb.get(key);
            if(value != null){
                System.out.println(key + ":" + value);
            }
        }
        if(!hdb.close()){
            int ecode = hdb.ecode();
            System.err.println("close error: " + hdb.errmsg(ecode));
        }

    }
}

% javac TCHDBEX.java
% ls
TCHDBEX.class TCHDBEX.java% java TCHDBEX
hop
foo:hop
bar:step
baz:jump

% ls
TCHDBEX.class TCHDBEX.java  casket.tch

インストールは成功した模様。

PacoをUbuntuにインストール

2009-05-10T17:53:00.007+09:00

"make install"したソフトウェアを管理できる超便利ツール「Paco」
を参考にPacoをUbuntuにインストール。


sudo apt-get update
sudo apt-get install build-essential
sudo apt-get install libgtkmm-2.4-dev
wget http://downloads.sourceforge.net/paco/paco-2.0.6.tar.gz
tar zxvf paco-2.0.6.tar.gz
cd paco-2.0.6/
./configure
make
sudo make install
sudo make logme

Clojure 1.0

2009-05-08T09:20:00.005+09:00

Clojure 1.0 - Clojure Clojure | Google Groups
Clojure: Clojure 1.0News about Clojure by Rich Hickey

ついにClojureの1.0がでました。
Congratulation!

zsh上でsvnの補完がエラーになる

2009-05-04T11:30:00.004+09:00

zsh上でsvnコマンドの補完が
_arguments:comparguments:303: invalid argument: ARG
というメッセージとともにエラーになる症状になった。
どうも、subversion1.5とzsh4.3.4の組み合わせで、
zsh4.3.4の
/usr/share/zsh/4.3.4/functions/_subversion
が、subversion1.5での変更に対応していないことが原因のよう。
http://d.hatena.ne.jp/sotarok/20080813/1218649287
こちらを参考に、


% curl -O http://gvn.googlecode.com/svn/trunk/contrib/zsh/_subversion
% sudo mv _subversion /usr/share/zsh/site-functions

で解決しました。
ありがとうございます。

ScalaをUbuntuにインストール

2009-05-01T21:48:00.004+09:00

UbuntuにScalaをインストール。
http://lovehateubuntu.blogspot.com/2008/05/adventures-in-scala-part-i.html
http://d.hatena.ne.jp/riue/20080105/1199552108
を参考にしました。

Javaは前回のClojureのインストール時に
sudo apt-get install openjdk-6-jdk
でインストール済み。

wget http://www.scala-lang.org/downloads/distrib/files/scala-2.7.4.final.tgz
tar xzvf scala-2.7.4.final.tgz 
sudo mv scala-2.7.4.final /usr/share/scala
sudo ln -s /usr/share/scala/bin/scala /usr/local/bin/scala
sudo ln -s /usr/share/scala/bin/scalac /usr/local/bin/scalac

ビルドをしていないので、
ダウンロードしてパスを通しただけです。
.emacsに

(add-to-list 'load-path "/usr/share/scala/misc/scala-tool-support/emacs")
(require 'scala-mode-auto)
(setq scala-interpreter "/usr/local/bin/scala")

Clojureの紹介

2009-04-29T22:50:00.008+09:00

Clojureの特徴。

-JavaVMの上で動く
-Lispの新しい方言
-動的型付けの純粋でない関数型言語
-STMによる並行処理
-豊富でimmutableなデータ型
-遅延シーケンス

というところあたり。

1.JavaVMの上で動く
JavaVMの上で動く言語は、ScalaやGroovy、ABCLなど
たくさんある。

これらの中でClojureは新しいほう。
JavaVMの上での言語開発の利点は、Javaとの連携が容易で
Javaの豊富なライブラリを利用できる点と、
JVMの高いパフォーマンス、マルチプラットフォーム対応
ガーベージコレクタなどの恩恵を受けられる点など。

2.Lispの新しい方言

Common LispやR5RSなどの仕様によらない、
新しく設計されたLispの方言。
当然コードはS式でマクロが使える。
新しいLispという意味では、ポールグレアムのArcなどと同様ですね。
JVM上のLispは、Common Lisp on JVMのABCL、
Scheme on JVM のSISCやKAWAなどがあるが、
新規設計のLisp方言onJVMはClojure以外にいまのところなさそう。
リーダマクロが独自定義できない、
末尾再帰最適化がないなどの理由から、
Common Lispなどからきたユーザには窮屈に感じられそう。

Lisp以外からきたユーザには、Common LispやSchemeより
逆にとっつきが良いかもしれない。

主観的な感想だが、
Common Lispの無骨な感じや歴史からくる複雑さ、
Schemeの原理主義的な感じから比べて、
Clojureには、PythonやRubyのような
ユーザに優しい雰囲気が感じられる。

3.動的型付けの純粋でない関数型言語
Haskellなどのような純粋関数型ではないが、
immutableなデータ型とそれへの参照を使って状態が管理されるので、
Python,Common Lisp などに比べると、
比較的破壊的な操作が少ない。

基本はimmutableで、プロセスディクショナリやetsを持っている
Erlangとポジションは似ているかも。

ここまでは前提条件的なもの。
ここからが、とくにClojureの魅力的な点。

4.STMによる並行処理

STMは、Software Transactional Memory
wikipedia:ソフトウェアトランザクショナルメモリ
複数スレッドからの共有メモリの読み書きを、
データベースのトランザクション処理のように制御する方法。
"Beautiful concurrency" Simon Peyton Jones (PDF)
や、書籍「ビューティフルコード」など。
並行制御として、ErlangやScalaのようなアクターモデルと
このSTMと、あとはロックを使う方法などがあって、
どれが有用なのかについては、議論の的になっているようだ。

5.豊富でimmutableなデータ型

データ型の便利さにPythonに近いものを感じる。
Erlangの持つimmutableでファーストクラスのコンテナは、
リストとタプルしかない。
dictはリストの組み合わせでしかなく、リレラルもない。
これはErlangの弱点だと思われる。
また、immutableなコンテナは、パフォーマンスの低下を
招きかねないが、そこらへんも効率よく実装されているらしい。

6.遅延シーケンス
Clojureはもちろん遅延評価ではないが、
遅延シーケンスが言語レベルでサポートされている。
Pythonのイテレータやジェネレータの感覚にとても近いものを感じるが、
遅延シーケンス自体もimmutableなので、状態を内在している
Pythonのジェネレータより扱いやすい点もありそう。
ここは要調査。

Clojureのlistとvector初見

2009-04-29T21:33:00.005+09:00

Clojureは便利な組み込みのデータ型を備えている。
これらはぜんぶが全部immutable、変更不可能になっている。
でも参照を扱う仕組みが別にあって、参照先が変更可能なので、
ErlangやHaskellより命令的に破壊的な操作？を書ける。
そこはSTMと絡んでくるので後回し。

Clojureは動的型で、Pythonの組み込み関数typeと同じように
型について調べる事ができる。

user> (type 1)
java.lang.Integer

整数や文字列などはJavaのクラスがそのまま使われているようだ。
JavaのVMの仕組みはわからないけれど、
Javaは静的型なので、こういったインスタンスやクラスの情報は
なんらかの形でラップされて扱われているんだろうと思われる。
型もふつうのオブジェクトのようで、比較ができる。

user> (= (type 1) (type 3))
true
user> (= (type 1) (type 30000000000000000000000))
false

typeのtype、Pythonだとメタクラスになるところだが、
おなじようなものだろう。

user> (type (type 1))
java.lang.Class
user> (type (type (type 1)))
java.lang.Class

文字列や、大きい整数もこんな具合。

user> (type "abc")
java.lang.String
user> (type 10000000000000)
java.lang.Long
user> (type 100000000000000000000000000)
java.math.BigInteger

コンテナ型は、Clojure独自に定義されている。
immutableということで、PersistentHoge
という名前が付けられている。

user> (type [])
clojure.lang.PersistentVector

これはPersistentVector。単にvectorと呼ばれることの方が多い。
IPersistentVectorというのは明らかにインターフェースと思われるが
MultiMethodsと関係してくるのだろうか？今は不明。


user> (type ())
clojure.lang.PersistentList$EmptyList

こっちはPersistentList。EmptyListとついているのが気になる。
これがうわさのMetadataか？
listとvectorが別にある。vectorの方が可変長配列でlistはリンクリスト
ってことだろうか。
listは当然だがvectorにもリテラルが用意されている。

user> [1 2 3 4]
[1 2 3 4]
user> [1, 2, 3, 4]
[1 2 3 4]

カンマは、あっても無くても同じ。
好き嫌いが分かれそうだが、僕は嫌いじゃない。
関数で生成することもできる。

user> (vector 1 2 3 4)
[1 2 3 4]
user> (vector)
[]

listのほうはこんなかんじ。

user> '(1 2 3 4)
(1 2 3 4)
user> '(1, 2, 3, 4)
(1 2 3 4)
user> (list 1 2 3 4)
(1 2 3 4)

Lispですね。

Clojureのインストール（Ubuntu 9.04）

2009-04-29T10:45:00.007+09:00

Clojure on Ubuntu
を参考にUbuntu 9.04にClojureをインストール。

sudo apt-get install openjdk-6-jdk
sudo apt-get install ant subversion git-core
mkdir ~/opt
cd ~/opt
svn co http://clojure.googlecode.com/svn/trunk clojure
svn up
cd clojure
ant
mkdir ~/.clojure
cp clojure.jar ~/.clojure
cd ~/.clojure
java -cp clojure.jar clojure.lang.Repl
user=> (+ 1 2)
3
cd ~/opt
git clone git://github.com/kevinoneill/clojure-contrib.git
cd clojure-contrib
git pull
ant -Dclojure.jar=../clojure/clojure.jar
cp *.jar ~/.clojure
emacs ~/.profile
=============
export CLOJURE_EXT=~/.clojure
PATH=$PATH:~/opt/clojure-contrib/launchers/bash
alias clj=clj-env-dir
=============

user=> (System/getProperty "java.class.path")
"/home/xxx/.clojure/clojure.jar
:/home/xxx/.clojure/clojure-contrib-slim.jar
:/home/xxx/.clojure/clojure-contrib.jar"