scalaのプレースホルダ構文

scalaには、プレースホルダ構文なるものがあって、関数をかなり簡潔にかけるようになっている。
関数脳じゃないから理解するのにかなり苦労した。

Listのforeachで使ってみると

    val list = List(1, 2, 3, 4, 5)

    // プレースホルダ構文を使用しない場合、
    // foreachに対してこんな感じに関数を渡す。
    list.foreach((x:Int) => println(x))

    // プレースホルダ構文を使った場合
    // 関数のパラメータをプレースホルダ(_)として書くことができる。
    list.foreach(println _)

foreachに対して関数を渡すときと比べるとかなり簡潔になっている。
ただし、プレースホルダ構文は関数内で１度のみの使用しか認められていない。
なので、こんなコードはNGとなる。

    val list = List(1, 2, 3, 4, 5)
    // 関数内で、２度プレースホルダを使用しているので構文エラーとなる。
    list.foreach(
      println (_)
      println (_)
    )

Listのsortで使ってみると

    
    val l = List(1, 3, 2, 5, 4)
    // sortは、引数を２つ必要とするので、それぞれをプレースホルダにできる。
    println(l.sort(_ < _))

    val hoges = List(new Hoge(3), new Hoge(1), new Hoge(2))
    // こんな感じにプレースホルダの属性を参照することもできる。
    println(hoges.sort(_.id < _.id))

    class Hoge(x:Int) {
      val id:Int = x

      override def toString = "Hoge{" + id + "}"
    }

JDBC経由でシーケンスを使用して採番した値の取得

insert文などでシーケンスを使用して採番を行った値を取得する場合、
JDBCの自動採番キー機能と、Oracleの拡張SQL文を使用する２パターンの方法がある。
Oracle拡張機能を使用した場合、１レコード更新なら良いが複数レコード更新になると、
クライアント側コードもOracleが拡張したJDBCの機能を使う必要があり、ちと面倒になる。

JDBCの自動採番キー機能

        // Statement取得時に、自動採番キーの項目を第二引数で指定する。
        // この例では、ID列がシーケンスでの採番対象なので『ID』と指定している。
        PreparedStatement statement = con.prepareStatement(
                "insert into test (ID, NAME) values (TEST_SEQ.nextval, ?)",
                new String[]{"ID"});
        try {
            statement.setString(1, "hogehoge");
            statement.execute();
            // SQLを実行後、statementオブジェクトからgetGeneratedKeysを呼び出して、
            // 採番キーの結果を取得する。（１行だけなのにResultSetってのが面倒・・・）
            ResultSet keys = statement.getGeneratedKeys();
            try {
                // ResultSetと同じ感じに値を取得する。
                // ただし、カラム名指定でのアクセスは出来ないので、
                // インデックス指定でアクセスする必要がある。
                keys.next();
                int id = keys.getInt(1);
                System.out.println("id = " + id);
            } finally {
                keys.close();
            }
        } finally {
            statement.close();
        }
        con.commit();
    }

Oracleの拡張SQL機能

        // Oracleで拡張された、returning intoを使用して、
        // IDカラムの値をバインド変数（OUTパラメータに代入する。)
        // なお、SQL文はbegin endで囲い、無名pl/sqlにする必要がある。
        CallableStatement statement = con.prepareCall(
                "begin insert into test (ID, NAME) "
                        + " values (TEST_SEQ.nextval, ?) returning id into ?; end;");

        try {
            statement.setString(1, "hoge");
            // OUTパラメータのタイプを指定する。
            statement.registerOutParameter(2, Types.INTEGER);
            statement.execute();
            // SQL実行後に、OUTパラメータの値を取得する。
            int id = statement.getInt(2);
            System.out.println("id = " + id);
            con.commit();
        } finally {
            statement.close();
        }

Oracleの拡張SQL機能で複数行更新の場合

        // returning intoを使用してID列をOUTパラメータに代入する。
        // SQL文は、通常のSQL文形式で、statementはOracleJDBCのstatementにキャストする。
        OracleCallableStatement statement = (OracleCallableStatement)
                con.prepareCall("update test set id = test_seq.nextval returning id into ?");
        try {
            // registerReturnParameterを呼び出して、データ型を設定する。
            // なお、この時に設定するデータ型はOracleTypesがもつ定数を使用する。
            statement.registerReturnParameter(1, OracleTypes.INTEGER);
            int count = statement.executeUpdate();
            System.out.println("count = " + count);

            // getReturnResultSetを呼び出して、OUTパラメータの結果セット(ResultSet)を取得する。
            ResultSet set = statement.getReturnResultSet();
            try {
                while (set.next()) {
                    System.out.println("set.getInt(1) = " + set.getInt(1));
                }
            } finally {
                set.close();
            }
        } finally {
            statement.close();
        }

scalaのコンストラクタ

scalaでコンストラクタの定義方法

コード

// 基本コンストラクタ
// 基本コンストラクタは、クラス宣言で定義する（クラスのパラメータとして定義する）
class Hoge(s: String, n: Int) {

  // 補助コンストラクタ（基本コンストラクタをオーバーロードする場合に定義する。）
  // 補助コンストラクタの最初のステップでは、必ず他のコンスとラクアを呼び出す必要がある。
  // この仕様に従うと、最後には必ず基本コンストラクタが呼び出される。
  def this(s: String) = this (s, 0)
  def this(n: Int) = this ("hoge", n)

  // コンストラクタの変数は、privateなインスタンス変数となる
  override def toString = s + ":" + n
}

object Hoge {

  def main(args: Array[String]) {
    // 基本コンストラクタに指定した値が出力される。
    println(new Hoge("string", 1))

    // 補助コンストラクタに指定した値と、補助コンストラクタで指定しているデフォルト値が出力される。
    println(new Hoge("hoge"))
    println(new Hoge(-1))
  }
}

実行結果

string:1
hoge:0
hoge:-1

rubyで例外処理

rubyでの例外処理方法

javaで言うところのtry-catchに似たbegin-rescueブロックを使用した例外処理ができる。

例外処理の基本

下記コードだと、beginブロック内で発生した例外(StandardError）をrescueブロックで補足して処理をしている。
rubyでは、rescueブロックで例外を指定しないとStandardError(JavaでのRuntimeException)が暗黙的に補足される。

def hoge
  raise RuntimeError, "message"
end

begin     # javaでのtry
  hoge
rescue    # javaでのcatch

  # 補足した例外は、グローバル変数の「$!」で参照できる。
  puts  "error, #{$!.message}"  
end

begin
  hoge
# 例外を捕捉時に例外を変数に格納することも可能
# 下記のように「=> 変数名」とすると、変数に代入することができる。
rescue => exception
  puts "error, #{exception.message}"
end

特定の例外を捕捉

rescueブロックで例外クラスを指定すると特定の例外のみを補足することができる。
複数のrescueブロックを定義した場合、javaと同じように最初にマッチしたrescueブロックが実行される。

def hoge(n)
  raise TypeError, "Type error." unless n.is_a? Integer
  n / 0
end

begin
  hoge(0)
# ZeroDivisionErrorを捕捉
rescue ZeroDivisionError => e
  puts  "error, #{e.message}"
end

begin
  hoge('a')
# TypeErrorを捕捉
rescue TypeError => e
  puts "error, #{e.message}"
end

begin
  hoge('a')
# ZeroDivisionErrorとTypeErrorを捕捉
rescue ZeroDivisionError, TypeError => e
  puts "error, #{e.message}"
end