botlistprojects/botbert/scala/botlist_richsql.scala

   1 //
   2 // 4/20/2007
   3
   4 import scala.Console
   5 import java.io._
   6 import scala.xml._
   7 import java.net._
   8 import org.jdom._
   9 import org.jdom.{Document => JDocument}
  10 import java.util.{Iterator => JIterator}
  11 import org.jdom.input._
  12 import scala.dbc._
  13 import scala.dbc.Syntax._
  14 import scala.dbc.statement._
  15 import scala.dbc.statement.expression._
  16 import scala.dbc.value._
  17 import scala.dbc.syntax._
  18 import syntax.Statement._
  19 import scala.dbc.statement.{Select => DBCSelect}
  20 import java.sql.{DriverManager, Connection, ResultSet, PreparedStatement, Statement, Date }
  21 import DriverManager.{getConnection => connect};
  22
  23 import RichSQL._;
  24
  25 //------------------------------------------------
  26 // Rich Scala JDBC
  27 // From http://scala.sygneca.com/code/simplifying-jdbc
  28 //------------------------------------------------
  29
  30 object RichSQL {
  31
  32     implicit def query[X](s: String, f: RichResultSet => X)(implicit stat: Statement) = {
  33         def strm(rs: ResultSet): Stream[X] =
  34             if (rs.next) Stream.cons(f(new RichResultSet(rs)), strm(rs)) else { rs.close(); Stream.empty };
  35         strm(stat.executeQuery(s));
  36     }
  37
  38     implicit def conn2Statement(conn: Connection): Statement = conn.createStatement;
  39
  40     implicit def rrs2Byte(rs: RichResultSet) = rs.nextByte;
  41     implicit def rrs2Int(rs: RichResultSet) = rs.nextInt;
  42     implicit def rrs2Long(rs: RichResultSet) = rs.nextLong;
  43     implicit def rrs2Float(rs: RichResultSet) = rs.nextFloat;
  44     implicit def rrs2Double(rs: RichResultSet) = rs.nextDouble;
  45     implicit def rrs2String(rs: RichResultSet) = rs.nextString;
  46
  47     implicit def resultSet2Rich(rs: ResultSet) = new RichResultSet(rs);
  48     implicit def rich2ResultSet(r: RichResultSet) = r.rs;
  49
  50     class RichResultSet(val rs: ResultSet) {
  51
  52         var pos = 1
  53         def apply(i: Int) = { pos = i; this }
  54
  55         def nextInt: Int = { val ret = rs.getInt(pos); pos = pos + 1; ret }
  56         def nextString: String = { val ret = rs.getString(pos); pos = pos + 1; ret }
  57         def nextLong: Long = { val ret = rs.getLong(pos); pos = pos + 1; ret }
  58         def nextFloat: Float = { val ret = rs.getFloat(pos); pos = pos + 1; ret }
  59         def nextDouble: Double = { val ret = rs.getDouble(pos); pos = pos + 1; ret }
  60         def nextByte: Byte = { val ret = rs.getByte(pos); pos = pos + 1; ret }
  61
  62         def foldLeft[X](init: X)(f: (ResultSet, X) => X): X = rs.next match {
  63             case false => init
  64             case true => foldLeft(f(rs, init))(f)
  65         }
  66         def map[X](f: ResultSet => X) = {
  67             var ret = List[X]()
  68             while (rs.next())
  69                 ret = f(rs) :: ret
  70             ret;
  71         }
  72     }
  73
  74     implicit def str2RichPrepared(s: String)(implicit conn: Connection): RichPreparedStatement = conn prepareStatement(s);
  75
  76     implicit def ps2Rich(ps: PreparedStatement) = new RichPreparedStatement(ps);
  77     implicit def rich2PS(r: RichPreparedStatement) = r.ps;
  78     class RichPreparedStatement(val ps: PreparedStatement) {
  79       var pos = 1;
  80       private def inc = { pos = pos + 1; this }
  81       def execute = { pos = 1; ps.execute }
  82       def <<! = execute;
  83       def <<(o: String) = { ps.setString(pos, o); inc }
  84       def <<(x: Date) = { ps.setDate(pos, x); inc }
  85       def <<(x: Byte) = { ps.setByte(pos, x); inc }
  86       def <<(x: Long) = { ps.setLong(pos, x); inc }
  87       def <<(b: Boolean) = { ps.setBoolean(pos, b); inc }
  88       def <<(i: Int) = { ps.setInt(pos, i); inc }
  89       def <<(f: Float) = { ps.setFloat(pos, f); inc }
  90       def <<(d: Double) = { ps.setDouble(pos, d); inc }
  91     }
  92
  93     implicit def conn2Rich(conn: Connection) = new RichConnection(conn);
  94
  95     class RichConnection(val conn: Connection) {
  96         def <<(sql: String) = new RichStatement(conn.createStatement) << sql;
  97         def <<(sql: Seq[String]) = new RichStatement(conn.createStatement) << sql;
  98         def << = new RichStatement(conn.createStatement);
  99     }
 100
 101     implicit def st2Rich(s: Statement) = new RichStatement(s);
 102     implicit def rich2St(rs: RichStatement) = rs.s;
 103
 104     class RichStatement(val s: Statement) {
 105       def <<(sql: String) = { s.execute(sql); this }
 106       def <<(sql: Seq[String]) = { for (val x <- sql) s.execute(x); this }
 107     }
 108
 109 }
 110
 111 //------------------------------------------------
 112 // End of Rich Scala JDBC
 113 //------------------------------------------------
 114