knjrbfw 0.0.3

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

@@ -0,0 +1,327 @@
+class KnjDB_mysql
+	attr_reader :knjdb, :conn, :escape_table, :escape_col, :escape_val, :esc_table
+	attr_accessor :tables, :cols, :indexes
+	
+	def initialize(knjdb_ob)
+		@knjdb = knjdb_ob
+		@encoding = @knjdb.opts[:encoding]
+		@escape_table = "`"
+		@escape_col = "`"
+		@escape_val = "'"
+		@esc_table = "`"
+		@esc_col = "`"
+		@mutex = Mutex.new
+		
+		if @knjdb.opts.has_key?(:port)
+			@port = @knjdb.opts[:port].to_i
+		else
+			@port = 3306
+		end
+		
+		@subtype = @knjdb.opts[:subtype]
+		reconnect
+	end
+	
+	def reconnect
+		if !@subtype or @subtype == "mysql"
+			@conn = Mysql.real_connect(@knjdb.opts[:host], @knjdb.opts[:user], @knjdb.opts[:pass], @knjdb.opts[:db], @port)
+		elsif @subtype == "mysql2"
+			require "rubygems"
+			require "mysql2"
+			
+			args = {
+        :host => @knjdb.opts[:host],
+        :username => @knjdb.opts[:user],
+        :password => @knjdb.opts[:pass],
+        :database => @knjdb.opts[:db],
+        :port => @port,
+        :symbolize_keys => true
+			}
+			
+			@query_args = @knjdb.opts[:query_args]
+			@query_args = {} if !@query_args
+			
+			pos_args = [:as, :async, :cast_booleans, :database_timezone, :application_timezone, :cache_rows, :connect_flags, :cast]
+			pos_args.each do |key|
+        args[key] = @knjdb.opts[key] if @knjdb.opts.has_key?(key)
+			end
+			
+			@conn = Mysql2::Client.new(args)
+		elsif @subtype == "java"
+			if !@jdbc_loaded
+				require "java"
+				
+				if File.exists?("/usr/share/java/mysql-connector-java.jar")
+					require "/usr/share/java/mysql-connector-java.jar"
+				else
+					require File.dirname(__FILE__) + "/mysql-connector-java-5.1.13-bin.jar"
+				end
+				
+				import "com.mysql.jdbc.Driver"
+				@jdbc_loaded = true
+			end
+			
+			@conn = java.sql::DriverManager.getConnection("jdbc:mysql://#{@knjdb.opts[:host]}:#{@port}/#{@knjdb.opts[:db]}?user=#{@knjdb.opts[:user]}&password=#{@knjdb.opts[:pass]}&populateInsertRowWithDefaultValues=true&zeroDateTimeBehavior=round")
+			query("SET SQL_MODE = ''")
+		else
+			raise "Unknown subtype: #{@subtype}"
+		end
+		
+		query_conn(@conn, "SET NAMES '#{esc(@encoding)}'") if @encoding
+	end
+	
+	def query_conn(conn, str)
+		if @subtype == "java"
+			stmt = conn.createStatement
+			
+			if str.match(/insert\s+into\s+/i) or str.match(/update\s+/i) or str.match(/^\s*delete\s+/i) or str.match(/^\s*create\s*/i)
+				return stmt.execute(str)
+			else
+				return stmt.executeQuery(str)
+			end
+		elsif conn.respond_to?(:query)
+			return conn.query(str)
+		else
+			raise "Could not figure out the way to execute the query on #{conn.class.name}."
+		end
+	end
+	
+	def query(string)
+		string = string.to_s
+		string = string.force_encoding("UTF-8") if @encoding == "utf8" and string.respond_to?(:force_encoding)
+		
+		@mutex.synchronize do
+			if !@subtype or @subtype == "mysql"
+				begin
+					return KnjDB_mysql_result.new(self, @conn.query(string))
+				rescue Mysql::Error => e
+					if e.message == "MySQL server has gone away"
+						reconnect
+						retry
+					else
+						raise e
+					end
+				end
+			elsif @subtype == "mysql2"
+				begin
+					return KnjDB_mysql2_result.new(@conn.query(string, @query_args))
+				rescue Mysql2::Error => e
+					if e.message == "MySQL server has gone away" or e.message == "closed MySQL connection"
+						reconnect
+						retry
+					elsif e.message == "This connection is still waiting for a result, try again once you have the result"
+						sleep 0.1
+						retry
+					else
+						print string
+						raise e
+					end
+				end
+			elsif @subtype == "java"
+				begin
+					return KnjDB_java_mysql_result.new(@knjdb, query_conn(@conn, string))
+				rescue => e
+					if e.to_s.index("No operations allowed after connection closed") != nil
+						reconnect
+						retry
+					end
+					
+					raise e
+				end
+			else
+				raise "Unknown subtype: '#{@subtype}'."
+			end
+		end
+	end
+	
+	def escape(string)
+		if !@subtype or @subtype == "mysql"
+			return @conn.escape_string(string.to_s)
+		elsif @subtype == "mysql2"
+			return @conn.escape(string.to_s)
+		elsif @subtype == "java"
+			#This is copied from the Ruby/MySQL framework at: http://www.tmtm.org/en/ruby/mysql/
+			return string.to_s.gsub(/([\0\n\r\032\'\"\\])/) do
+				case $1
+					when "\0" then "\\0"
+					when "\n" then "\\n"
+					when "\r" then "\\r"
+					when "\032" then "\\Z"
+					else "\\" + $1
+				end
+			end
+		else
+			raise "Unknown subtype: '#{@subtype}'."
+		end
+	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
+		if !@subtype or @subtype == "mysql"
+			@mutex.synchronize do
+				return @conn.insert_id
+			end
+		elsif @subtype == "mysql2"
+			@mutex.synchronize do
+				return @conn.last_id
+			end
+		else
+			data = self.query("SELECT LAST_INSERT_ID() AS id").fetch
+			return data[:id] if data.has_key?(:id)
+			raise "Could not figure out last inserted ID."
+		end
+	end
+	
+	def close
+		@mutex.synchronize do
+			@conn.close
+		end
+	end
+	
+	def destroy
+		@conn = nil
+		@knjdb = nil
+		@mutex = nil
+		@subtype = nil
+		@encoding = nil
+		@query_args = nil
+		@port = nil
+	end
+	
+	def insert_multi(tablename, arr_hashes)
+		sql = "INSERT INTO `#{esc_table(tablename)}` ("
+		
+		first = true
+		arr_hashes[0].keys.each do |col_name|
+			sql += "," if !first
+			first = false if first
+			sql += "`#{esc_col(col_name)}`"
+		end
+		
+		sql += ") VALUES ("
+		
+		first = true
+		arr_hashes.each do |hash|
+			sql += "),(" if !first
+			first = false if first
+			
+			first_key = true
+			hash.each do |key, val|
+				sql += "," if !first_key
+				first_key = false if first_key
+				sql += "'#{esc(val)}'"
+			end
+		end
+		
+		sql += ")"
+		
+		query(sql)
+	end
+end
+
+class KnjDB_mysql_result
+	def initialize(driver, result)
+		@driver = driver
+		@result = result
+		@mutex = Mutex.new
+		
+		if @result
+			@keys = []
+			keys = @result.fetch_fields
+			keys.each do |key|
+				@keys << key.name.to_sym
+			end
+		end
+	end
+	
+	def fetch
+		return fetch_hash_symbols if @driver.knjdb.opts[:return_keys] == "symbols"
+		return fetch_hash_strings
+	end
+	
+	def fetch_hash_strings
+		@mutex.synchronize do
+			return @result.fetch_hash
+		end
+	end
+	
+	def fetch_hash_symbols
+		@mutex.synchronize do
+			fetched = @result.fetch_row
+			return false if !fetched
+			
+			ret = {}
+			count = 0
+			@keys.each do |key|
+				ret[key] = fetched[count]
+				count += 1
+			end
+			
+			return ret
+		end
+	end
+end
+
+class KnjDB_mysql2_result
+	def initialize(result)
+		@result = result.to_a
+		@count = 0
+		@mutex = Mutex.new
+	end
+	
+	def fetch
+		@mutex.synchronize do
+			ret = @result[@count]
+			return false if !ret
+			
+			realret = {}
+			ret.each do |key, val|
+				realret[key.to_sym] = val
+			end
+			
+			@count += 1
+			return realret
+		end
+	end
+end
+
+class KnjDB_java_mysql_result
+	def initialize(knjdb, result)
+		@knjdb = knjdb
+		@result = result
+		@mutex = Mutex.new
+	end
+	
+	def read_meta
+		@result.before_first
+		meta = @result.meta_data
+		
+		@keys = []
+		0.upto(meta.column_count - 1) do |count|
+			@keys << meta.column_name(count + 1).to_sym
+		end
+	end
+	
+	def fetch
+		@mutex.synchronize do
+			read_meta if !@keys
+			status = @result.next
+			return false if !status
+			
+			ret = {}
+			0.upto(@keys.length - 1) do |count|
+				ret[@keys[count].to_sym] = @result.string(count + 1)
+			end
+			
+			return ret
+		end
+	end
+end

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

@@ -0,0 +1,130 @@
+class KnjDB_mysql::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"]
+		
+		data["maxlength"] = 255 if data["type"] == "varchar" and !data.has_key?("maxlength")
+		
+		sql = "`#{data["name"]}` #{data["type"]}"
+		sql += "(#{data["maxlength"]})" if data["maxlength"]
+		sql += " PRIMARY KEY" if data["primarykey"]
+		sql += " AUTO_INCREMENT" if data["autoincr"]
+		sql += " NOT NULL" if !data["null"]
+		
+		if data.has_key?("default_func")
+			sql += " DEFAULT #{data["default_func"]}"
+		elsif data.has_key?("default") and data["default"] != false
+			sql += " DEFAULT '#{@db.escape(data["default"])}'"
+		end
+		
+		sql += " COMMENT '#{@db.escape(data["comment"])}'" if data.has_key?("comment")
+		sql += " AFTER `#{@db.esc_col(data["after"])}`" if data["after"] and !data["first"]
+		sql += " FIRST" if data["first"]
+		
+		return sql
+	end
+end
+
+class KnjDB_mysql::Columns::Column
+	attr_reader :args
+	
+	def initialize(args)
+		@args = args
+		@db = @args[:db]
+	end
+	
+	def name
+		return @args[:data][:Field]
+	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
+		end
+		
+		return @type
+	end
+	
+	def null?
+		return false if @args[:data][:Null] == "NO"
+		return true
+	end
+	
+	def maxlength
+		self.type
+		return @maxlength if @maxlength
+		return false
+	end
+	
+	def default
+		return false if !@args[:data][:Default]
+		return @args[:data][:Default]
+	end
+	
+	def primarykey?
+		return false if @args[:data][:pk].to_i == 0
+		return true
+	end
+	
+	def autoincr?
+		return true if @args[:data][:Extra].index("auto_increment") != nil
+		return false
+	end
+	
+	def comment
+		return @args[:data][:Comment]
+	end
+	
+	def drop
+		@args[:db].query("ALTER TABLE `#{@args[:table].name}` DROP COLUMN `#{self.name}`")
+	end
+	
+	def change(data)
+		esc_col = @args[:driver].escape_col
+		col_escaped = "#{esc_col}#{@db.esc_col(self.name)}#{esc_col}"
+		table_escape = "#{@args[:driver].escape_table}#{@args[:driver].esc_table(@args[:table].name)}#{@args[:driver].escape_table}"
+		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_s = newdata["type"].to_s
+		@db.query("ALTER TABLE #{table_escape} CHANGE #{col_escaped} #{@db.cols.data_sql(newdata)}")
+		@args[:table].list = nil if data.has_key?("name") and data["name"] != self.name
+	end
+end

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

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