knjrbfw 0.0.3

data/lib/knj/knjdb/libknjdb.rb

@@ -0,0 +1,438 @@
+class Knj::Db
+  autoload :Dbtime, "#{File.dirname(__FILE__)}/dbtime.rb"
+  attr_reader :opts, :conn, :conns, :int_types
+  
+  def initialize(opts)
+    self.setOpts(opts) if opts != nil
+    
+    @int_types = ["int", "bigint", "tinyint", "smallint", "mediumint"]
+    
+    if !@opts[:threadsafe]
+      @mutex = Mutex.new
+    end
+  end
+  
+  def col_table
+    return "`"
+  end
+  
+  def args
+    return @opts
+  end
+  
+  def setOpts(arr_opts)
+    @opts = {}
+    arr_opts.each do |key, val|
+      @opts[key.to_sym] = val
+    end
+    
+    if @opts[:type] == "sqlite3" and RUBY_PLATFORM == "java"
+      @opts[:type] = "java_sqlite3"
+    elsif @opts[:type] == "mysql" and RUBY_PLATFORM == "java"
+      @opts[:subtype] = "java"
+    elsif @opts[:type] == "sqlite3" and RUBY_PLATFORM.index("mswin32") != nil
+      @opts[:type] = "sqlite3_ironruby"
+    end
+    
+    self.connect
+  end
+  
+  def connect
+    if @opts[:threadsafe]
+      @conns = Knj::Threadhandler.new
+      
+      @conns.on_spawn_new do
+        self.spawn
+      end
+      
+      @conns.on_inactive do |data|
+        data[:obj].close
+      end
+      
+      @conns.on_activate do |data|
+        data[:obj].reconnect
+      end
+    else
+      @conn = self.spawn
+    end
+  end
+  
+  def spawn
+    raise "No type given." if !@opts[:type]
+    
+    fpaths = [
+      "drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}.rb",
+      "libknjdb_" + @opts[:type] + ".rb"
+    ]
+    fpaths.each do |fpath|
+      rpath = "#{File.dirname(__FILE__)}/#{fpath}"
+      
+      if (!@opts.has_key?(:require) or @opts[:require]) and File.exists?(rpath)
+        require rpath
+        break
+      end
+    end
+    
+    return Kernel.const_get("KnjDB_" + @opts[:type]).new(self)
+  end
+  
+  def get_and_register_thread
+    raise "KnjDB-object is not in threadding mode." if !@conns
+    
+    db = @conns.get_and_lock
+    tid = self.__id__
+    Thread.current[:knjdb] = {} if !Thread.current[:knjdb]
+    Thread.current[:knjdb][tid] = db
+  end
+  
+  def free_thread
+    tid = self.__id__
+    
+    if Thread.current[:knjdb] and Thread.current[:knjdb].has_key?(tid)
+      db = Thread.current[:knjdb][tid]
+      Thread.current[:knjdb].delete(tid)
+      @conns.free(db) if @conns
+    end
+  end
+  
+  def close
+    @conn.close if @conn
+    @conns.destroy if @conns
+    
+    @conn = nil
+    @conns = nil
+  end
+  
+  def clone_conn
+    return Knj::Db.new(@opts)
+  end
+  
+  def copy_to(db, args = {})
+    data["tables"].each do |table|
+      table_args = nil
+      table_args = args["tables"][table["name"].to_s] if args and args["tables"] and args["tables"][table["name"].to_s]
+      next if table_args and table_args["skip"]
+      table.delete("indexes") if table.has_key?("indexes") and args["skip_indexes"]
+      db.tables.create(table["name"], table)
+      
+      limit_from = 0
+      limit_incr = 1000
+      
+      loop do
+        ins_arr = []
+        q_rows = self.select(table["name"], {}, {"limit_from" => limit_from, "limit_to" => limit_incr})
+        while d_rows = q_rows.fetch
+          col_args = nil
+          
+          if table_args and table_args["columns"]
+            d_rows.each do |col_name, col_data|
+              col_args = table_args["columns"][col_name.to_s] if table_args and table_args["columns"]
+              d_rows[col_name] = "" if col_args and col_args["empty"]
+            end
+          end
+          
+          ins_arr << d_rows
+        end
+        
+        break if ins_arr.empty?
+        
+        db.insert_multi(table["name"], ins_arr)
+        limit_from += limit_incr
+      end
+    end
+  end
+  
+  def data
+    tables_ret = []
+    tables.list.each do |name, table|
+      tables_ret << table.data
+    end
+    
+    return {
+      "tables" => tables_ret
+    }
+  end
+  
+  def insert(tablename, arr_insert, args = {})
+    sql = ""
+    
+    conn_exec do |driver|
+      sql += "INSERT INTO #{driver.escape_table}#{tablename.to_s}#{driver.escape_table} ("
+      
+      first = true
+      arr_insert.each do |key, value|
+        if first
+          first = false
+        else
+          sql += ", "
+        end
+        
+        sql += "#{driver.escape_col}#{key.to_s}#{driver.escape_col}"
+      end
+      
+      sql += ") VALUES ("
+      
+      first = true
+      arr_insert.each do |key, value|
+        if first
+          first = false
+        else
+          sql += ", "
+        end
+        
+        sql += "#{driver.escape_val}#{driver.escape(value.to_s)}#{driver.escape_val}"
+      end
+      
+      sql += ")"
+      
+      driver.query(sql)
+      return driver.lastID if args[:return_id]
+    end
+  end
+  
+  def insert_multi(tablename, arr_hashes)
+    conn_exec do |driver|
+      if driver.respond_to?(:insert_multi)
+        return false if arr_hashes.empty?
+        driver.insert_multi(tablename, arr_hashes)
+      else
+        arr_hashes.each do |hash|
+          self.insert(tablename, hash)
+        end
+      end
+    end
+  end
+  
+  def update(tablename, arr_update, arr_terms = {})
+    return false if arr_update.empty?
+    
+    conn_exec do |driver|
+      sql = ""
+      sql += "UPDATE #{driver.escape_col}#{tablename.to_s}#{driver.escape_col} SET "
+      
+      first = true
+      arr_update.each do |key, value|
+        if first
+          first = false
+        else
+          sql += ", "
+        end
+        
+        sql += "#{driver.escape_col}#{key.to_s}#{driver.escape_col} = "
+        sql += "#{driver.escape_val}#{driver.escape(value.to_s)}#{driver.escape_val}"
+      end
+      
+      if arr_terms and arr_terms.length > 0
+        sql += " WHERE #{self.makeWhere(arr_terms, driver)}"
+      end
+      
+      driver.query(sql)
+    end
+  end
+  
+  def select(tablename, arr_terms = nil, args = nil)
+    sql = ""
+    
+    conn_exec do |driver|
+      sql += "SELECT * FROM #{driver.escape_table}#{tablename.to_s}#{driver.escape_table}"
+      
+      if arr_terms != nil and !arr_terms.empty?
+        sql += " WHERE #{self.makeWhere(arr_terms, driver)}"
+      end
+      
+      if args != nil
+        if args["orderby"]
+          sql += " ORDER BY "
+          sql += args["orderby"]
+        end
+        
+        if args["limit"]
+          sql += " LIMIT " + args["limit"].to_s
+        end
+        
+        if args["limit_from"] and args["limit_to"]
+          raise "'limit_from' was not numeric: '#{args["limit_from"]}'." if !Knj::Php.is_numeric(args["limit_from"])
+          raise "'limit_to' was not numeric: '#{args["limit_to"]}'." if !Knj::Php.is_numeric(args["limit_to"])
+          
+          sql += " LIMIT #{args["limit_from"]}, #{args["limit_to"]}"
+        end
+      end
+      
+      return driver.query(sql)
+    end
+    
+    raise "Something went wrong."
+  end
+  
+  def selectsingle(tablename, arr_terms = nil, args = {})
+    args["limit"] = 1
+    return self.select(tablename, arr_terms, args).fetch
+  end
+  
+  def single(tablename, arr_terms = nil, args = {})
+    args["limit"] = 1
+    return self.select(tablename, arr_terms, args).fetch
+  end
+  
+  def delete(tablename, arr_terms)
+    sql = ""
+    
+    conn_exec do |driver|
+      sql += "DELETE FROM #{driver.escape_table}#{tablename.to_s}#{driver.escape_table}"
+      
+      if arr_terms != nil
+        sql += " WHERE #{self.makeWhere(arr_terms, driver)}"
+      end
+      
+      driver.query(sql)
+    end
+  end
+  
+  def makeWhere(arr_terms, driver)
+    sql = ""
+    
+    first = true
+    arr_terms.each do |key, value|
+      if first
+        first = false
+      else
+        sql += " AND "
+      end
+      
+      sql += "#{driver.escape_col}#{key.to_s}#{driver.escape_col} = #{driver.escape_val}#{driver.escape(value)}#{driver.escape_val}"
+    end
+    
+    return sql
+  end
+  
+  def conn_exec
+    if Thread.current[:knjdb]
+      tid = self.__id__
+      
+      if Thread.current[:knjdb].has_key?(tid)
+        yield(Thread.current[:knjdb][tid])
+        return nil
+      end
+    end
+    
+    if @conns
+      conn = @conns.get_and_lock
+      
+      begin
+        yield(conn)
+        return nil
+      ensure
+        @conns.free(conn)
+      end
+    elsif @conn
+      @mutex.synchronize do
+        yield(@conn)
+        return nil
+      end
+    end
+    
+    raise "Could not figure out how to find a driver to use?"
+  end
+  
+  def query(string)
+    conn_exec do |driver|
+      return driver.query(string)
+    end
+  end
+  
+  def q(str)
+    ret = self.query(str)
+    
+    if block_given?
+      while data = ret.fetch
+        yield data
+      end
+    end
+    
+    return ret
+  end
+  
+  def lastID
+    conn_exec do |driver|
+      return driver.lastID
+    end
+  end
+  
+  alias :last_id :lastID
+  
+  def escape(string)
+    conn_exec do |driver|
+      return driver.escape(string)
+    end
+  end
+  
+  alias :esc :escape
+  
+  def esc_col(str)
+    conn_exec do |driver|
+      return driver.esc_col(str)
+    end
+  end
+  
+  def esc_table(str)
+    conn_exec do |driver|
+      return driver.esc_table(str)
+    end
+  end
+  
+  def date_out(date_obj)
+    return Knj::Datet.in(date_obj).dbstr
+  end
+  
+  def date_in(date_obj)
+    return Knj::Datet.in(date_obj)
+  end
+  
+  def tables
+    conn_exec do |driver|
+      if !driver.tables
+        require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_tables" if (!@opts.has_key?(:require) or @opts[:require])
+        driver.tables = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Tables).new(
+          :driver => driver,
+          :db => self
+        )
+      end
+      
+      return driver.tables
+    end
+  end
+  
+  def cols
+    if !@cols
+      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_columns" if (!@opts.has_key?(:require) or @opts[:require])
+      @cols = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Columns).new(
+        :driver => @conn,
+        :db => self
+      )
+    end
+    
+    return @cols
+  end
+  
+  def indexes
+    if !@indexes
+      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_indexes" if (!@opts.has_key?(:require) or @opts[:require])
+      @indexes = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Indexes).new(
+        :driver => @conn,
+        :db => self
+      )
+    end
+    
+    return @indexes
+  end
+  
+  def method_missing(method_name, *args)
+    conn_exec do |driver|
+      if driver.respond_to?(method_name.to_sym)
+        return driver.send(method_name, *args)
+      end
+    end
+    
+    raise "Method not found: #{method_name}"
+  end
+end

data/lib/knj/knjdb/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/lib/knj/knjdb/libknjdb_row.rb

@@ -0,0 +1,149 @@
+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 Knj::Errors::InvalidData.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.has_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 Knj::Errors::NotFound.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.has_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.has_key?(key)
+			return @data[key]
+		elsif @data.has_key?(key.to_sym)
+			return @data[key.to_sym]
+		elsif @data.has_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.has_key?(:title)
+			return @data[:title]
+		elsif @data.has_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 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.has_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