knjrbfw 0.0.110 → 0.0.114

data/lib/knj/knjdb/libknjdb_java_sqlite3.rb

@@ -1,83 +0,0 @@
-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/lib/knj/knjdb/libknjdb_row.rb

@@ -1,153 +0,0 @@
-class Knj::Db_row
-  attr_reader :args, :data
-  
-  def is_knj?; return true; end
-  
-  def initialize(args)
-    @args = {}
-    args.each do |key, value|
-      @args[key.to_sym] = value
-    end
-    
-    @args[:db] = $db if !@args[:db] and $db and $db.class.to_s == "Knj::Db"
-    @args[:objects] = $objects if !@args[:objects] and $objects and $objects.is_a?(Knj::Objects)
-    @args[:col_id] = :id if !@args[:col_id]
-    raise "No table given." if !@args[:table]
-    
-    if @args[:data] and (@args[:data].is_a?(Integer) or @args[:data].is_a?(Fixnum) or @args[:data].is_a?(String))
-      @data = {@args[:col_id].to_sym => @args[:data].to_s}
-      self.reload
-    elsif @args[:data] and @args[:data].is_a?(Hash)
-      @data = {}
-      @args[:data].each do |key, value|
-        @data[key.to_sym] = value
-      end
-    elsif @args[:id]
-      @data = {}
-      @data[@args[:col_id].to_sym] = @args[:id]
-      self.reload
-    else
-      raise ArgumentError.new("Invalid data: #{@args[:data].to_s} (#{@args[:data].class.to_s})")
-    end
-  end
-  
-  def db
-    if !@args[:force_selfdb]
-      curthread = Thread.current
-      if curthread.is_a?(Knj::Thread) and curthread[:knjappserver] and curthread[:knjappserver][:db]
-        return curthread[:knjappserver][:db]
-      end
-    end
-    
-    return @args[:db]
-  end
-  
-  def ob
-    return @args[:objects] if @args.key?(:objects)
-    return $ob if $ob and $ob.is_a?(Knj::Objects)
-    return false
-  end
-  
-  alias :objects :ob
-  
-  def reload
-    last_id = self.id
-    data = self.db.single(@args[:table], {@args[:col_id] => self.id})
-    if !data
-      raise Errno::ENOENT.new("Could not find any data for the object with ID: '#{last_id}' in the table '#{@args[:table].to_s}'.")
-    end
-    
-    @data = {}
-    data.each do |key, value|
-      @data[key.to_sym] = value
-    end
-  end
-  
-  def update(newdata)
-    self.db.update(@args[:table], newdata, {@args[:col_id] => self.id})
-    self.reload
-    
-    if self.ob
-      self.ob.call("object" => self, "signal" => "update")
-    end
-  end
-  
-  def delete
-    self.db.delete(@args[:table], {@args[:col_id] => self.id})
-    self.destroy
-  end
-  
-  def destroy
-    @args = nil
-    @data = nil
-  end
-  
-  def has_key?(key)
-    return @data.key?(key.to_sym)
-  end
-  
-  def [](key)
-    raise "No valid key given." if !key
-    raise "No data was loaded on the object? Maybe you are trying to call a deleted object?" if !@data
-    
-    if @data.key?(key)
-      return @data[key]
-    elsif @data.key?(key.to_sym)
-      return @data[key.to_sym]
-    elsif @data.key?(key.to_s)
-      return @data[key.to_s]
-    end
-    
-    raise "No such key: #{key.to_s}."
-  end
-  
-  def []=(key, value)
-    self.update(key.to_sym => value)
-    self.reload
-  end
-  
-  def id
-    return @data[@args[:col_id]]
-  end
-  
-  def title
-    if @args[:col_title]
-      return @data[@args[:col_title].to_sym]
-    end
-    
-    if @data.key?(:title)
-      return @data[:title]
-    elsif @data.key?(:name)
-      return @data[:name]
-    end
-    
-    raise "'col_title' has not been set for the class: '#{self.class.to_s}'."
-  end
-  
-  alias :name :title
-  
-  def each(&args)
-    return @data.each(&args)
-  end
-  
-  def to_hash
-    return @data.clone
-  end
-  
-  def esc(str)
-    return self.db.escape(str)
-  end
-  
-  def method_missing(*args)
-    func_name = args[0].to_s
-    if match = func_name.match(/^(\S+)\?$/) and @data.key?(match[1].to_sym)
-      if @data[match[1].to_sym] == "1" or @data[match[1].to_sym] == "yes"
-        return true
-      elsif @data[match[1].to_sym] == "0" or @data[match[1].to_sym] == "no"
-        return false
-      end
-    end
-    
-    raise sprintf("No such method: %s", func_name)
-  end
-end

data/lib/knj/knjdb/libknjdb_sqlite3_ironruby.rb

@@ -1,69 +0,0 @@
-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 KnjDB_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 KnjDB_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 KnjDB_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/lib/knj/knjdb/query_buffer.rb

@@ -1,87 +0,0 @@
-#This class buffers a lot of queries and flushes them out via transactions.
-class Knj::Db::Query_buffer
-  #Constructor. Takes arguments to be used and a block.
-  def initialize(args)
-    @args = args
-    @queries = []
-    @inserts = {}
-    @queries_count = 0
-    @debug = @args[:debug]
-    @lock = Mutex.new
-    
-    STDOUT.puts "Query buffer started." if @debug
-    
-    if block_given?
-			begin
-				yield(self)
-			ensure
-				self.flush
-			end
-		end
-  end
-  
-  #Adds a query to the buffer.
-  def query(str)
-    @lock.synchronize do
-      STDOUT.print "Adding to buffer: #{str}\n" if @debug
-      @queries << str
-      @queries_count += 1
-    end
-    
-    self.flush if @queries_count >= 1000
-    return nil
-  end
-  
-  #Delete as on a normal Knj::Db.
-  #===Examples
-  # db.q_buffer do |buffer|
-  #   buffer.delete(:users, {:id => 5})
-  # end
-  def delete(table, where)
-    STDOUT.puts "Delete called on table #{table} with arguments: '#{where}'." if @debug
-    self.query(@args[:db].delete(table, where, :return_sql => true))
-    return nil
-  end
-  
-  #Plans to inset a hash into a table. It will only be inserted when flush is called.
-  #===Examples
-  # db.q_buffer do |buffer|
-  #   buffer.insert(:users, {:name => "John Doe"})
-  # end
-  def insert(table, data)
-    @lock.synchronize do
-      @inserts[table] = [] if !@inserts.key?(table)
-      @inserts[table] << data
-      @queries_count += 1
-    end
-    
-    self.flush if @queries_count >= 1000
-    return nil
-  end
-  
-  #Flushes all queries out in a transaction. This will automatically be called for every 1000 queries.
-  def flush
-    return nil if @queries_count <= 0
-    
-    @lock.synchronize do
-      @args[:db].transaction do
-        @queries.shift(1000).each do |str|
-          STDOUT.print "Executing via buffer: #{str}\n" if @debug
-          @args[:db].q(str)
-        end
-        
-        @inserts.each do |table, datas_arr|
-          while !datas_arr.empty?
-            datas_chunk_arr = datas_arr.shift(1000)
-            @args[:db].insert_multi(table, datas_chunk_arr)
-          end
-        end
-      end
-      
-      @inserts.clear
-      @queries_count = 0
-    end
-    
-    return nil
-  end
-end