baza 0.0.0

data/include/drivers/sqlite3/libknjdb_java_sqlite3.rb

@@ -0,0 +1,83 @@
+class KnjDB_java_sqlite3
+  def escape_table
+    return "`"
+  end
+  
+  def escape_col
+    return "`"
+  end
+  
+  def escape_val
+    return "'"
+  end
+  
+  def initialize(knjdb_ob)
+    @knjdb = knjdb_ob
+    
+    if @knjdb.opts[:sqlite_driver]
+      require @knjdb.opts[:sqlite_driver]
+    else
+      require File.dirname(__FILE__) + "/sqlitejdbc-v056.jar"
+    end
+    
+    require "java"
+    import "org.sqlite.JDBC"
+    @conn = java.sql.DriverManager::getConnection("jdbc:sqlite:" + @knjdb.opts[:path])
+    @stat = @conn.createStatement
+  end
+  
+  def query(string)
+    begin
+      return KnjDB_java_sqlite3_result.new(@stat.executeQuery(string))
+    rescue java.sql.SQLException => e
+      if e.message == "java.sql.SQLException: query does not return ResultSet"
+        #ignore it.
+      else
+        raise e
+      end
+    end
+  end
+  
+  def fetch(result)
+    return result.fetch
+  end
+  
+  def escape(string)
+    if (!string)
+      return ""
+    end
+    
+      string = string.gsub("'", "\\'")
+    return string
+  end
+  
+  def lastID
+    return @conn.last_insert_row_id
+  end
+end
+
+class KnjDB_java_sqlite3_result
+  def initialize(rs)
+    @rs = rs
+    @index = 0
+    
+    if rs
+      @metadata = rs.getMetaData
+      @columns_count = @metadata.getColumnCount
+    end
+  end
+  
+  def fetch
+    if !@rs.next
+      return false
+    end
+    
+    tha_return = {}
+    for i in (1..@columns_count)
+      col_name = @metadata.getColumnName(i)
+      tha_return.store(col_name, @rs.getString(i))
+    end
+    
+    return tha_return
+  end
+end

data/include/drivers/sqlite3/libknjdb_sqlite3_ironruby.rb

@@ -0,0 +1,69 @@
+require "Mono.Data.Sqlite, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756"
+require "Mono.Data.SqliteClient, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756"
+
+class Baza::Driver::Sqlite3_ironruby
+  def escape_table
+    return "`"
+  end
+  
+  def escape_col
+    return "`"
+  end
+  
+  def escape_val
+    return "'"
+  end
+  
+  def initialize(knjdb_ob)
+    @knjdb = knjdb_ob
+    @conn = Mono::Data::SqliteClient::SqliteConnection.new("URI=file:" + @knjdb.opts[:path] + ",version=3")
+    @conn.Open
+  end
+  
+  def query(string)
+    dbcmd = @conn.CreateCommand
+    dbcmd.CommandText = string
+    reader = dbcmd.ExecuteReader
+    return Baza::Driver::Sqlite3_ironruby_result.new(reader)
+  end
+  
+  def escape(string)
+    if (!string)
+      return ""
+    end
+    
+      string = string.gsub("'", "\\'")
+    return string
+  end
+  
+  def lastID
+    return @conn.last_insert_row_id
+  end
+end
+
+class Baza::Driver::Sqlite3_ironruby_result
+  def initialize(reader)
+    @reader = reader
+  end
+  
+  def fetch
+    if !@reader.Read
+      return false
+    end
+    
+    ret = {}
+    
+    count = 0
+    while true
+      begin
+        ret[@reader.get_name(count)] = @reader.get_string(count)
+      rescue IndexError => e
+        break
+      end
+      
+      count += 1
+    end
+    
+    return ret
+  end
+end

data/include/drivers/sqlite3/sqlite3.rb

@@ -0,0 +1,184 @@
+#This class handels SQLite3-specific behaviour.
+class Baza::Driver::Sqlite3
+  attr_reader :knjdb, :conn, :sep_table, :sep_col, :sep_val, :symbolize
+  attr_accessor :tables, :cols, :indexes
+  
+  #Constructor. This should not be called manually.
+  def initialize(knjdb_ob)
+    @sep_table = "`"
+    @sep_col = "`"
+    @sep_val = "'"
+    
+    @knjdb = knjdb_ob
+    @path = @knjdb.opts[:path] if @knjdb.opts[:path]
+    @path = @knjdb.opts["path"] if @knjdb.opts["path"]
+    @symbolize = true if !@knjdb.opts.key?(:return_keys) or @knjdb.opts[:return_keys] == "symbols"
+    
+    @knjdb.opts[:subtype] = "java" if !@knjdb.opts.key?(:subtype) and RUBY_ENGINE == "jruby"
+    raise "No path was given." if !@path
+    
+    if @knjdb.opts[:subtype] == "java"
+      if @knjdb.opts[:sqlite_driver]
+        require @knjdb.opts[:sqlite_driver]
+      else
+        require "#{File.dirname(__FILE__)}/../../../jruby/sqlitejdbc-v056.jar"
+      end
+      
+      require "java"
+      import "org.sqlite.JDBC"
+      @conn = java.sql.DriverManager::getConnection("jdbc:sqlite:#{@knjdb.opts[:path]}")
+      @stat = @conn.createStatement
+    elsif @knjdb.opts[:subtype] == "rhodes"
+      @conn = SQLite3::Database.new(@path, @path)
+    else
+      @conn = SQLite3::Database.open(@path)
+      @conn.results_as_hash = true
+      @conn.type_translation = false
+    end
+  end
+  
+  #Executes a query against the driver.
+  def query(string)
+    begin
+      if @knjdb.opts[:subtype] == "rhodes"
+        return Baza::Driver::Sqlite3_result.new(self, @conn.execute(string, string))
+      elsif @knjdb.opts[:subtype] == "java"
+        begin
+          return Baza::Driver::Sqlite3_result_java.new(self, @stat.executeQuery(string))
+        rescue java.sql.SQLException => e
+          if e.message.to_s.index("query does not return ResultSet") != nil
+            return Baza::Driver::Sqlite3_result_java.new(self, nil)
+          else
+            raise e
+          end
+        end
+      else
+        return Baza::Driver::Sqlite3_result.new(self, @conn.execute(string))
+      end
+    rescue => e
+      #Add SQL to the error message.
+      raise e.class, "#{e.message} (SQL: #{string})"
+    end
+  end
+  
+  #SQLite3 driver doesnt support unbuffered queries??
+  alias query_ubuf query
+  
+  #Escapes a string to be safe to used in a query.
+  def escape(string)
+    #This code is taken directly from the documentation so we dont have to rely on the SQLite3::Database class. This way it can also be used with JRuby and IronRuby...
+    #http://sqlite-ruby.rubyforge.org/classes/SQLite/Database.html
+    return string.to_s.gsub(/'/, "''")
+  end
+  
+  #Escapes a string to be used as a column.
+  def esc_col(string)
+    string = string.to_s
+    raise "Invalid column-string: #{string}" if string.index(@sep_col) != nil
+    return string
+  end
+  
+  alias :esc_table :esc_col
+  alias :esc :escape
+  
+  #Returns the last inserted ID.
+  def lastID
+    return @conn.last_insert_row_id if @conn.respond_to?(:last_insert_row_id)
+    return self.query("SELECT last_insert_rowid() AS id").fetch[:id].to_i
+  end
+  
+  #Closes the connection to the database.
+  def close
+    @conn.close
+  end
+  
+  #Starts a transaction, yields the database and commits.
+  def transaction
+    @conn.transaction do
+      yield(@knjdb)
+    end
+  end
+end
+
+#This class handels results when running in JRuby.
+class Baza::Driver::Sqlite3_result_java
+  def initialize(driver, rs)
+    @index = 0
+    retkeys = driver.knjdb.opts[:return_keys]
+    
+    if rs
+      metadata = rs.getMetaData
+      columns_count = metadata.getColumnCount
+      
+      @rows = []
+      while rs.next
+        row_data = {}
+        for i in (1..columns_count)
+          col_name = metadata.getColumnName(i)
+          col_name = col_name.to_s.to_sym if retkeys == "symbols"
+          row_data[col_name] = rs.getString(i)
+        end
+        
+        @rows << row_data
+      end
+    end
+  end
+  
+  #Returns a single result.
+  def fetch
+    return false if !@rows
+    ret = @rows[@index]
+    return false if !ret
+    @index += 1
+    return ret
+  end
+  
+  #Loops over every result and yields them.
+  def each
+    while data = self.fetch
+      yield(data)
+    end
+  end
+end
+
+#This class handels the result when running MRI (or others).
+class Baza::Driver::Sqlite3_result
+  #Constructor. This should not be called manually.
+  def initialize(driver, result_array)
+    @result_array = result_array
+    @index = 0
+    
+    if driver.knjdb.opts[:return_keys] == "symbols"
+      @symbols = true
+    else
+      @symbols = false
+    end
+  end
+  
+  #Returns a single result.
+  def fetch
+    result_hash = @result_array[@index]
+    return false if !result_hash
+    @index += 1
+    
+    ret = {}
+    result_hash.each do |key, val|
+      if (Float(key) rescue false)
+        #do nothing.
+      elsif @symbols and !key.is_a?(Symbol)
+        ret[key.to_sym] = val
+      else
+        ret[key] = val
+      end
+    end
+    
+    return ret
+  end
+  
+  #Loops over every result yielding them.
+  def each
+    while data = self.fetch
+      yield(data)
+    end
+  end
+end

data/include/drivers/sqlite3/sqlite3_columns.rb

@@ -0,0 +1,177 @@
+#This class handels the SQLite3-specific behaviour for columns.
+class Baza::Driver::Sqlite3::Columns
+  attr_reader :db
+  
+  #Constructor. This should not be called manually.
+  def initialize(args)
+    @args = args
+  end
+  
+  #Returns SQL for a knjdb-compatible hash.
+  def data_sql(data)
+    raise "No type given." if !data["type"]
+    type = data["type"].to_s
+    
+    if type == "enum"
+      type = "varchar"
+      data.delete("maxlength")
+    end
+    
+    data["maxlength"] = 255 if type == "varchar" and !data.key?("maxlength")
+    data["maxlength"] = 11 if type == "int" and !data.key?("maxlength") and !data["autoincr"] and !data["primarykey"]
+    type = "integer" if @args[:db].int_types.index(type) and (data["autoincr"] or data["primarykey"])
+    
+    sql = "`#{data["name"]}` #{type}"
+    sql << "(#{data["maxlength"]})" if data["maxlength"] and !data["autoincr"]
+    sql << " PRIMARY KEY" if data["primarykey"]
+    sql << " AUTOINCREMENT" if data["autoincr"]
+    
+    if !data["null"] and data.key?("null")
+      sql << " NOT NULL"
+      
+      if !data.key?("default") or !data["default"]
+        data["default"] = 0 if type == "int"
+      end
+    end
+    
+    if data.key?("default_func")
+      sql << " DEFAULT #{data["default_func"]}"
+    elsif data.key?("default") and data["default"] != false
+      sql << " DEFAULT '#{@args[:db].escape(data["default"])}'"
+    end
+    
+    return sql
+  end
+end
+
+#This class handels all the SQLite3-columns.
+class Baza::Driver::Sqlite3::Columns::Column
+  attr_reader :args
+  
+  #Constructor. This should not be called manually.
+  def initialize(args)
+    @args = args
+    @db = @args[:db]
+  end
+  
+  #Returns the name of the column.
+  def name
+    return @args[:data][:name]
+  end
+  
+  #Returns the columns table-object.
+  def table
+    return @db.tables[@args[:table_name]]
+  end
+  
+  #Returns the data of the column as a hash in knjdb-format.
+  def data
+    return {
+      "type" => self.type,
+      "name" => self.name,
+      "null" => self.null?,
+      "maxlength" => self.maxlength,
+      "default" => self.default,
+      "primarykey" => self.primarykey?,
+      "autoincr" => self.autoincr?
+    }
+  end
+  
+  #Returns the type of the column.
+  def type
+    if !@type
+      if match = @args[:data][:type].match(/^([A-z]+)$/)
+        @maxlength = false
+        type = match[0].to_sym
+      elsif match = @args[:data][:type].match(/^decimal\((\d+),(\d+)\)$/)
+        @maxlength = "#{match[1]},#{match[2]}"
+        type = :decimal
+      elsif match = @args[:data][:type].match(/^enum\((.+)\)$/)
+        @maxlength = match[1]
+        type = :enum
+      elsif match = @args[:data][:type].match(/^(.+)\((\d+)\)$/)
+        @maxlength = match[2]
+        type = match[1].to_sym
+      elsif @args[:data].key?(:type) and @args[:data][:type].to_s == ""
+        #A type can actually be empty in SQLite... Wtf?
+        return @args[:data][:type]
+      end
+      
+      if type == :integer
+        @type = :int
+      else
+        @type = type
+      end
+      
+      raise "Still not type? (#{@args[:data]})" if @type.to_s.strip.length <= 0
+    end
+    
+    return @type
+  end
+  
+  #Returns true if the column allows null. Otherwise false.
+  def null?
+    return false if @args[:data][:notnull].to_i == 1
+    return true
+  end
+  
+  #Returns the maxlength of the column.
+  def maxlength
+    self.type if !@maxlength
+    return @maxlength if @maxlength
+    return false
+  end
+  
+  #Returns the default value of the column.
+  def default
+    def_val = @args[:data][:dflt_value]
+    if def_val.to_s.slice(0..0) == "'"
+      def_val = def_val.to_s.slice(0)
+    end
+    
+    if def_val.to_s.slice(-1..-1) == "'"
+      def_val = def_val.to_s.slice(0, def_val.length - 1)
+    end
+    
+    return false if @args[:data][:dflt_value].to_s.length == 0
+    return def_val
+  end
+  
+  #Returns true if the column is the primary key.
+  def primarykey?
+    return false if @args[:data][:pk].to_i == 0
+    return true
+  end
+  
+  #Returns true if the column is auto-increasing.
+  def autoincr?
+    return true if @args[:data][:pk].to_i == 1 and @args[:data][:type].to_s == "integer"
+    return false
+  end
+  
+  #Drops the column from the table.
+  def drop
+    self.table.copy("drops" => self.name)
+  end
+  
+  #Changes data on the column. Like the name, type, maxlength or whatever.
+  def change(data)
+    newdata = data.clone
+    
+    newdata["name"] = self.name if !newdata.key?("name")
+    newdata["type"] = self.type if !newdata.key?("type")
+    newdata["maxlength"] = self.maxlength if !newdata.key?("maxlength") and self.maxlength
+    newdata["null"] = self.null? if !newdata.key?("null")
+    newdata["default"] = self.default if !newdata.key?("default")
+    newdata["primarykey"] = self.primarykey? if !newdata.key?("primarykey")
+    
+    @type = nil
+    @maxlength = nil
+    
+    new_table = self.table.copy(
+      "alter_columns" => {
+        self.name.to_s => newdata
+      }
+    )
+  end
+end