knjrbfw 0.0.3

data/lib/knj/knjdb/drivers/mysql/knjdb_mysql_tables.rb

@@ -0,0 +1,255 @@
+class KnjDB_mysql::Tables
+	attr_reader :db, :driver
+	attr_accessor :list
+	
+	def initialize(args)
+		@args = args
+		@db = @args[:db]
+		@driver = @args[:driver]
+		@subtype = @db.opts[:subtype]
+		@list_mutex = Mutex.new
+	end
+	
+	def [](table_name)
+		list = self.list
+		return list[table_name.to_s] if list[table_name.to_s]
+		raise Knj::Errors::NotFound.new("Table was not found: #{table_name}.")
+	end
+	
+	def list
+		if !@list
+      @list_mutex.synchronize do
+        list = {}
+        @db.q("SHOW TABLE STATUS") do |d_tables|
+          if @subtype == "java"
+            d_tables = {
+              :Name => d_tables[:TABLE_NAME],
+              :Engine => d_tables[:ENGINE],
+              :Version => d_tables[:VERSION],
+              :Row_format => d_tables[:ROW_FORMAT],
+              :Rows => d_tables[:TABLE_ROWS],
+              :Avg_row_length => d_tables[:AVG_ROW_LENGTH],
+              :Data_length => d_tables[:DATA_LENGTH],
+              :Max_data_length => d_tables[:MAX_DATA_LENGTH],
+              :Index_length => d_tables[:INDEX_LENGTH],
+              :Data_free => d_tables[:DATA_FREE],
+              :Auto_increment => d_tables[:AUTO_INCREMENT],
+              :Create_time => d_tables[:CREATE_TIME],
+              :Update_time => d_tables[:UPDATE_TIME],
+              :Check_time => d_tables[:CHECK_TIME],
+              :Collation => d_tables[:TABLE_COLLATION],
+              :Checksum => d_tables[:CHECKSUM],
+              :Create_options => d_tables[:CREATE_OPTIONS],
+              :Comment => d_tables[:TABLE_COMMENT]
+            }
+          end
+          
+          list[d_tables[:Name]] = KnjDB_mysql::Tables::Table.new(
+            :db => @db,
+            :driver => @driver,
+            :data => d_tables,
+            :tables => self
+          )
+        end
+        
+        @list = list
+      end
+		end
+		
+		return @list
+	end
+	
+	def create(name, data)
+		raise "No columns was given for '#{name}'." if !data["columns"] or data["columns"].empty?
+		
+		sql = "CREATE TABLE `#{name}` ("
+		
+		first = true
+		data["columns"].each do |col_data|
+			sql += ", " if !first
+			first = false if first
+			col_data.delete("after") if col_data["after"]
+			sql += @db.cols.data_sql(col_data)
+		end
+		
+		sql += ")"
+		
+		@db.query(sql)
+		@list = nil
+		
+		if data["indexes"]
+			table_obj = self[name]
+			table_obj.create_indexes(data["indexes"])
+		end
+	end
+end
+
+class KnjDB_mysql::Tables::Table
+	attr_accessor :list
+	
+	def initialize(args)
+		@args = args
+		@db = args[:db]
+		@driver = args[:driver]
+		@data = args[:data]
+		@subtype = @db.opts[:subtype]
+		
+		raise "Could not figure out name." if !@data[:Name]
+	end
+	
+	def name
+		return @data[:Name]
+	end
+	
+	def drop
+		sql = "DROP TABLE `#{self.name}`"
+		@db.query(sql)
+	end
+	
+	def optimize
+		raise "stub!"
+	end
+	
+	def column(name)
+		list = self.columns
+		return list[name] if list[name]
+		raise Knj::Errors::NotFound.new("Column not found: #{name}.")
+	end
+	
+	def columns
+		if !@list
+			@db.cols
+			@list = {}
+			sql = "SHOW FULL COLUMNS FROM `#{self.name}`"
+			
+			q_cols = @db.query(sql)
+			while d_cols = q_cols.fetch
+				if @subtype == "java"
+					d_cols = {
+						:Field => d_cols[:COLUMN_NAME],
+						:Type => d_cols[:COLUMN_TYPE],
+						:Collation => d_cols[:COLLATION_NAME],
+						:Null => d_cols[:IS_NULLABLE],
+						:Key => d_cols[:COLUMN_KEY],
+						:Default => d_cols[:COLUMN_DEFAULT],
+						:Extra => d_cols[:EXTRA],
+						:Privileges => d_cols[:PRIVILEGES],
+						:Comment => d_cols[:COLUMN_COMMENT]
+					}
+				end
+				
+				@list[d_cols[:Field]] = KnjDB_mysql::Columns::Column.new(
+					:table => self,
+					:db => @db,
+					:driver => @driver,
+					:data => d_cols
+				)
+			end
+		end
+		
+		return @list
+	end
+	
+	def indexes
+		if !@indexes_list
+			@db.indexes
+			@indexes_list = {}
+			
+			q_indexes = @db.query("SHOW INDEX FROM `#{self.name}`")
+			while d_indexes = q_indexes.fetch
+        if @subtype == "java"
+          d_indexes = {
+            :Table => d_indexes[:TABLE_NAME],
+            :Non_unique => d_indexes[:NON_UNIQUE],
+            :Key_name => d_indexes[:INDEX_NAME],
+            :Seq_in_index => d_indexes[:SEQ_IN_INDEX],
+            :Column_name => d_indexes[:COLUMN_NAME],
+            :Collation => d_indexes[:COLLATION],
+            :Cardinality => d_indexes[:CARDINALITY],
+            :Sub_part => d_indexes[:SUB_PART],
+            :Packed => d_indexes[:PACKED],
+            :Null => d_indexes[:NULLABLE],
+            :Index_type => d_indexes[:INDEX_TYPE],
+            :Comment => d_indexes[:COMMENT]
+          }
+        end
+        
+				next if d_indexes[:Key_name] == "PRIMARY"
+				
+				if !@indexes_list[d_indexes[:Key_name]]
+					@indexes_list[d_indexes[:Key_name]] = KnjDB_mysql::Indexes::Index.new(
+						:table => self,
+						:db => @db,
+						:driver => @driver,
+						:data => d_indexes
+					)
+				end
+				
+				@indexes_list[d_indexes[:Key_name]].columns << d_indexes[:Column_name]
+			end
+		end
+		
+		return @indexes_list
+	end
+	
+	def index(name)
+		list = self.indexes
+		return list[name] if list[name]
+		raise Knj::Errors::NotFound.new("Index not found: #{name}.")
+	end
+	
+	def create_columns(col_arr)
+		col_arr.each do |col_data|
+			sql = "ALTER TABLE `#{self.name}` ADD COLUMN #{@db.cols.data_sql(col_data)};"
+			@db.query(sql)
+		end
+	end
+	
+	def create_indexes(index_arr)
+		index_arr.each do |index_data|
+			raise "No name was given." if !index_data.has_key?("name") or index_data["name"].strip.length <= 0
+			raise "No columns was given on index #{index_data["name"]}." if index_data["columns"].empty?
+			
+			sql = "CREATE INDEX #{@db.escape_col}#{@db.esc_col(index_data["name"])}#{@db.escape_col} ON #{@db.escape_table}#{@db.esc_table(self.name)}#{@db.escape_table} ("
+			
+			first = true
+			index_data["columns"].each do |col_name|
+				sql += ", " if !first
+				first = false if first
+				
+				sql += "#{@db.escape_col}#{@db.esc_col(col_name)}#{@db.escape_col}"
+			end
+			
+			sql += ")"
+			
+			print sql + "\n"
+			@db.query(sql)
+		end
+	end
+	
+	def rename(newname)
+		oldname = self.name
+		@db.query("ALTER TABLE `#{oldname}` RENAME TO `#{newname}`")
+		@args[:tables].list[newname] = self
+		@args[:tables].list.delete(oldname)
+		@data[:Name] = newname
+	end
+	
+	def data
+		ret = {
+			"name" => name,
+			"columns" => [],
+			"indexes" => []
+		}
+		
+		columns.each do |name, column|
+			ret["columns"] << column.data
+		end
+		
+		indexes.each do |name, index|
+			ret["indexes"] << index.data if name != "PRIMARY"
+		end
+		
+		return ret
+	end
+end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3.rb

@@ -0,0 +1,93 @@
+class KnjDB_sqlite3
+  attr_reader :knjdb, :conn, :escape_table, :escape_col, :escape_val, :esc_table, :esc_col, :symbolize
+  attr_accessor :tables, :cols, :indexes
+  
+  def initialize(knjdb_ob)
+    @escape_table = "`"
+    @escape_col = "`"
+    @escape_val = "'"
+    @esc_table = "`"
+    @esc_col = "`"
+    
+    @knjdb = knjdb_ob
+    @path = @knjdb.opts[:path] if @knjdb.opts[:path]
+    @path = @knjdb.opts["path"] if @knjdb.opts["path"]
+    @symbolize = true if !@knjdb.opts.has_key?(:return_keys) or @knjdb.opts[:return_keys] == "symbols"
+    
+    raise "No path was given." if !@path
+    
+    if @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
+  
+  def query(string)
+    begin
+      if @knjdb.opts[:subtype] == "rhodes"
+        res = @conn.execute(string, string)
+      else
+        res = @conn.execute(string)
+      end
+    rescue Exception => e
+      print "SQL: #{string}\n"
+      raise e
+    end
+    
+    return KnjDB_sqlite3_result.new(self, res)
+  end
+  
+  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
+  
+  def esc_col(string)
+    string = string.to_s
+    raise "Invalid column-string: #{string}" if string.index(@escape_col) != nil
+    return string
+  end
+  
+  alias :esc_table :esc_col
+  alias :esc :escape
+  
+  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
+  
+  def close
+    @conn.close
+  end
+end
+
+class KnjDB_sqlite3_result
+  def initialize(driver, result_array)
+    @result_array = result_array
+    @index = 0
+    @retkeys = driver.knjdb.opts[:return_keys]
+  end
+  
+  def fetch
+    tha_return = @result_array[@index]
+    return false if !tha_return
+    @index += 1
+    
+    ret = {}
+    tha_return.each do |key, val|
+      if Knj::Php::is_numeric(key)
+        #do nothing.
+      elsif @retkeys == "symbols" and !key.is_a?(Symbol)
+        ret[key.to_sym] = val
+      else
+        ret[key] = val
+      end
+    end
+    
+    return ret
+  end
+end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_columns.rb

@@ -0,0 +1,151 @@
+class KnjDB_sqlite3::Columns
+	attr_reader :db, :driver
+	
+	def initialize(args)
+		@args = args
+		@db = @args[:db]
+		@driver = @args[:driver]
+	end
+	
+	def data_sql(data)
+		raise "No type given." if !data["type"]
+		type = data["type"]
+		
+		data["maxlength"] = 255 if type == "varchar" and !data.has_key?("maxlength")
+		type = "integer" if @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 += "(11)" if !data.has_key?("maxlength") and !data["autoincr"]
+		sql += " PRIMARY KEY" if data["primarykey"]
+		sql += " NOT NULL" if !data["null"] and data.has_key?("null")
+		
+		if data.has_key?("default_func")
+			sql += " DEFAULT #{data["default_func"]}"
+		elsif data.has_key?("default") and data["default"] != false
+			sql += " DEFAULT '#{@driver.escape(data["default"])}'"
+		end
+		
+		sql += " COMMENT '#{@driver.escape(data["comment"])}'" if data.has_key?("comment")
+		
+		return sql
+	end
+end
+
+class KnjDB_sqlite3::Columns::Column
+	attr_reader :args
+	
+	def initialize(args)
+		@args = args
+		@db = @args[:db]
+	end
+	
+	def name
+		return @args[:data][:name]
+	end
+	
+	def table
+		return @args[:table]
+	end
+	
+	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
+	
+	def type
+		if !@type
+			if match = @args[:data][:type].match(/^([A-z]+)$/)
+				@maxlength = false
+				type = match[0]
+			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]
+			end
+			
+			if type == "integer"
+				@type = "int"
+			else
+				@type = type
+			end
+		end
+		
+		return @type
+	end
+	
+	def null?
+		return false if @args[:data][:notnull].to_i == 1
+		return true
+	end
+	
+	def maxlength
+		self.type
+		return @maxlength if @maxlength
+		return false
+	end
+	
+	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
+	
+	def primarykey?
+		return true if @args[:data][:name] == "id"
+		return false if @args[:data][:pk].to_i == 0
+		return true
+	end
+	
+	def autoincr?
+		return true if @args[:data][:name] == "id"
+		return true if @args[:data][:pk].to_i >= 1
+		return false
+	end
+	
+	def drop
+		@args[:table].copy(
+			"drops" => self.name
+		)
+	end
+	
+	def change(data)
+		newdata = data.clone
+		
+		newdata["name"] = self.name if !newdata.has_key?("name")
+		newdata["type"] = self.type if !newdata.has_key?("type")
+		newdata["maxlength"] = self.maxlength if !newdata.has_key?("maxlength") and self.maxlength
+		newdata["null"] = self.null? if !newdata.has_key?("null")
+		newdata["default"] = self.default if !newdata.has_key?("default")
+		newdata.delete("primarykey") if newdata.has_key?("primarykey")
+		
+		@type = nil
+		@maxlength = nil
+		
+		new_table = self.table.copy(
+			"alter_columns" => {
+				self.name.to_s => newdata
+			}
+		)
+	end
+end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_indexes.rb

@@ -0,0 +1,29 @@
+class KnjDB_sqlite3::Indexes
+	def initialize(args)
+		@args = args
+	end
+end
+
+class KnjDB_sqlite3::Indexes::Index
+	attr_reader :columns
+	
+	def initialize(args)
+		@args = args
+		@columns = []
+	end
+	
+	def name
+		return @args[:data][:name]
+	end
+	
+	def drop
+		@args[:db].query("DROP INDEX `#{self.name}`")
+	end
+	
+	def data
+		return {
+			"name" => name,
+			"columns" => @columns
+		}
+	end
+end