webink 1.1.4

data/lib/webink/database.rb

@@ -0,0 +1,425 @@
+module Ink
+
+  # = Database class
+  # 
+  # == Config
+  # 
+  # Currently there are two types of databases supported, MySQL and
+  # SQLite3. Either way, you need to specify them in a config-file
+  # that is located inside the web project folder.
+  #
+  # Sample config for MySQL:
+  #   config = {
+  #     "escape_post_data"  => false,
+  #     "production"        => true,
+  #     "db_type"           => "mysql",
+  #     "db_user"           => "yourusername",
+  #     "db_pass"           => "yourpassword",
+  #     "db_database"       => "yourdatabase",
+  #     "db_server"         => "localhost",
+  #   }
+  #
+  # Sample config for SQLite3:
+  #   config = {
+  #     "escape_post_data"  => false,
+  #     "production"        => true,
+  #     "db_type"           => "sqlite3",
+  #     "db_server"         => "/full/path/to/database.sqlite",
+  #   }
+  #
+  # == Usage
+  #
+  # Create an Ink::Database instance with the self.create class method.
+  # Now it can be accessed via the public class variable 'database'.
+  # Once that is done, can use it to execute various SQL statements
+  # to gather data.
+  #
+  #   Ink::Database.database.query "SELECT * FROM x;"
+  #
+  # This is the most basic query, it returns an Array of results,
+  # and each element contains a Hash of column_name => column_entry.
+  #
+  #   Ink::Database.database.find "apples", "WHERE id < 10 GROUP BY color"
+  #   => self.query("SELECT * FROM apples WHERE id < 10 GROUP BY color;")
+  #
+  # This is different from the query method, because it returns an Array
+  # of Objects, created by the information stored in the database. So this
+  # find() will return you a set of Apple-instances.
+  #
+  #   Ink::Database.database.find_union "apple", 5, "tree", ""
+  #
+  # find_union allows you to retrieve data through a many_many reference.
+  # When you define a many_many relationship, a helper-table is created
+  # inside the database, which is apple_tree, in this case. This statement
+  # will fetch an Array of all Trees, that connect to the Apple with primary
+  # key 5. Notice that the relationship database apple_tree is put together
+  # by the alphabetically first, and then second classname. The last quotes
+  # allow additional query informations to be passed along (like group by)
+  #
+  #   Ink::Database.database.find_reference "tree", 1, "apple", ""
+  #
+  # find_reference is similar to find_union, only that it handles all
+  # other relationships. This statement above requires one Tree to have many
+  # Apples, so it will return an Array of Apples, all those that belong to
+  # the Tree with primary key 1
+  #
+  # Please close the dbinstance once you are done. This is automatically
+  # inserted in the init.rb of a project.
+  #
+  # 
+  #
+  class Database
+    private_class_method :new
+    @@database = nil
+  
+    # Private Constructor
+    # 
+    # Uses the config parameter to create a database
+    # connection, and will throw an error, if that is not
+    # possible.
+    # [param config:] Hash of config parameters
+    def initialize(config)
+      @type = config["db_type"]
+      if @type == "mysql"
+        @db = Mysql.real_connect(config["db_server"],config["db_user"],config["db_pass"],config["db_database"])
+        @db.reconnect = true
+      elsif @type == "sqlite3"
+        @db = SQLite3::Database.new(config["db_server"])
+      else
+        raise ArgumentError.new("Database undefined.")
+      end
+    end
+    
+    # Class method
+    # 
+    # Instanciates a new Database if none is found
+    # [param config:] Hash of config parameters
+    def self.create(config)
+      @@database = new(config) if not @@database
+    end
+    
+    # Class method
+    # 
+    # Removes an instanciated Database
+    def self.drop
+      @@database = nil if @@database
+    end
+    
+    # Class method
+    # 
+    # Returns the Database instance or raises a Runtime Error
+    # [returns:] Database instance
+    def self.database
+      (@@database) ? @@database : (raise RuntimeError.new("No Database found. Create one first"))
+    end
+    
+    # Instance method
+    # 
+    # This will retrieve all tables nested into
+    # the connected database.
+    # [returns:] Array of tables
+    def tables
+      result = Array.new
+      if @type == "mysql"
+        re = @db.query "show tables;"
+        re.each do |row|
+          row.each do |t|
+            result.push t
+          end
+        end
+      elsif @type == "sqlite3"
+        re = @db.query "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"
+        re.each do |row|
+          row.each do |t|
+            result.push t
+          end
+        end
+        re.close
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # Send an SQL query string to the database
+    # and retrieve a result set
+    # [param query:] SQL query string
+    # [returns:] Array of Hashes of column_name => column_entry
+    def query(query)
+      result = Array.new
+      if @type == "mysql"
+        re = @db.method("query").call query
+        if re
+          re.each_hash do |row|
+            result.push Hash.new
+            row.each do |k,v|
+              v = $&.to_i if v =~ /^[0-9]+$/
+              result[result.length-1][k] = v
+            end
+          end
+        end
+      elsif @type == "sqlite3"
+        re = @db.method("query").call query
+        re.each do |row|
+          result.push Hash.new
+          for i in 0...re.columns.length
+            row[i] = $&.to_i if row[i] =~ /^[0-9]+$/
+            result[result.length-1][re.columns[i]] = row[i]
+          end
+        end
+        re.close if not re.closed?
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # Closes the database connection, there is no way
+    # to reopen without creating a new Ink::Database instance
+    def close
+      if @type == "sqlite3" and not @db.closed?
+        begin
+          @db.close
+        rescue SQLite3::BusyException
+        end
+      elsif @type == "mysql"
+        @db.close
+      end
+      self.class.drop
+    end
+    
+    # Instance method
+    # 
+    # Attempts to fetch the last inserted primary key
+    # [returns:] primary key or nil
+    def last_inserted_pk
+      string = ""
+      if @type == "mysql"
+        string = "LAST_INSERT_ID()"
+      elsif @type == "sqlite3"
+        string = "last_insert_rowid()"
+      end
+      response = self.query "SELECT #{string} as id"
+      return (response.length > 0) ? response[0]["id"] : nil
+    end
+    
+    # Instance method
+    # 
+    # Creates the SQL syntax for the chosen database type
+    # to define a primary key, autoincrementing field
+    # [returns:] SQL syntax for a primary key field
+    def primary_key_autoincrement(pk="id")
+      result = Array.new
+      if @type == "mysql"
+        result = ["`#{pk}`", "INTEGER", "PRIMARY KEY", "AUTO_INCREMENT"]
+      elsif @type == "sqlite3"
+        result = ["`#{pk}`", "INTEGER", "PRIMARY KEY", "ASC"]
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # Delete something from the database.
+    # [param class_name:] Defines the table name
+    # [param params:] Additional SQL syntax like WHERE conditions (optional)
+    def remove(class_name, params="")
+      table_name = Ink::Model.str_to_tablename(class_name)
+      return if not table_name
+      self.query("DELETE FROM #{table_name} #{params};")
+    end
+    
+    # Instance method
+    # 
+    # Retrieve class instances, that are loaded with the database result set.
+    # [param class_name:] Defines the table name and resulting Instance classnames
+    # [param params:] Additional SQL syntax like WHERE conditions (optional)
+    # [returns:] Array of class_name instances from the SQL result set
+    def find(class_name, params="")
+      result = Array.new
+      table_name = Ink::Model.str_to_tablename(class_name)
+      return result if not table_name
+      
+      re = self.query("SELECT * FROM #{table_name} #{params};")
+      re.each do |entry|
+        instance = Ink::Model.classname(class_name).new entry
+        result.push instance
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # Retrieve class2 instances, that are related to the class1 instance with
+    # primary key class1_id. This is done via an additional relationship table.
+    # Only relevant for many_many relationships.
+    # [param class1:] Reference classname
+    # [param class1_id:] Primary key value of the reference classname
+    # [param class2:] Match classname
+    # [param params:] Additional SQL syntax like GROUP BY (optional)
+    # [returns:] Array of class2 instances from the SQL result set
+    def find_union(class1, class1_id, class2, params="")
+      result = Array.new
+      relationship = nil
+      Ink::Model.classname(class1).foreign.each do |k,v|
+        relationship = v if k.downcase == class2.downcase
+      end
+      return result if relationship != "many_many"
+      fk1 = Ink::Model.classname(class1).foreign_key[0]
+      pk2 = Ink::Model.classname(class2).primary_key[0]
+      fk2 = Ink::Model.classname(class2).foreign_key[0]
+      tablename1 = Ink::Model.str_to_tablename(class1)
+      tablename2 = Ink::Model.str_to_tablename(class2)
+      union_class = ((class1.downcase <=> class2.downcase) < 0) ? "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
+      re = self.query("SELECT #{tablename2}.* FROM #{union_class}, #{tablename2} WHERE #{union_class}.#{fk1} = #{class1_id} AND #{union_class}.#{fk2} = #{tablename2}.#{pk2} #{params};")
+      re.each do |entry|
+        instance = Ink::Model.classname(tablename2).new entry
+        result.push instance
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # Retrieve class2 instances, that are related to the class1 instance with
+    # primary key class1_id. Not relevant for many_many relationships
+    # [param class1:] Reference classname
+    # [param class1_id:] Primary key value of the reference classname
+    # [param class2:] Match classname
+    # [param params:] Additional SQL syntax like GROUP BY (optional)
+    # [returns:] Array of class2 instances from the SQL result set
+    def find_references(class1, class1_id, class2, params="")
+      result = Array.new
+      relationship = nil
+      Ink::Model.classname(class1).foreign.each do |k,v|
+        relationship = v if k.downcase == class2.downcase
+      end
+      return result if relationship == "many_many"
+      re = Array.new
+      fk1 = Ink::Model.classname(class1).foreign_key[0]
+      if ((class1.downcase <=> class2.downcase) < 0 and relationship == "one_one") or relationship == "one_many"
+        re = self.query "SELECT * FROM #{Ink::Model.str_to_tablename(class2)} WHERE #{Ink::Model.classname(class2).primary_key[0]}=(SELECT #{Ink::Model.classname(class2).foreign_key[0]} FROM #{Ink::Model.str_to_tablename(class1)} WHERE #{Ink::Model.classname(class1).primary_key[0]}=#{class1_id});"
+      else
+        re = self.query "SELECT * FROM #{Ink::Model.str_to_tablename(class2)} WHERE #{fk1} = #{class1_id} #{params};"
+      end
+      
+      re.each do |entry|
+        instance = Ink::Model.classname(class2).new entry
+        result.push instance
+      end
+      result
+    end
+    
+    # Instance method
+    # 
+    # This method attempts to remove all existing relationship data
+    # of instance with link of type: type. For one_one relationships
+    # this works only one way, requiring a second call later on before
+    # setting a new value.
+    # [param instance:] Instance of a class that refers to an existing database entry
+    # [param link:] the related class (not a String, but class reference)
+    # [param type:] relationship type
+    def delete_all_links(instance, link, type)
+      if type == "one_one"
+        firstclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class : link
+        secondclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? link : instance.class
+        key = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class.primary_key[0] : instance.class.foreign_key[0]
+        value = instance.method(instance.class.primary_key[0]).call
+        @db.query "UPDATE #{Ink::Model.str_to_tablename(firstclass.name)} SET #{secondclass.foreign_key[0]}=NULL WHERE #{key}=#{value};"
+      elsif type == "one_many" or type == "many_one"
+        firstclass = (type == "one_many") ? instance.class : link
+        secondclass = (type == "one_many") ? link : instance.class
+        key = (type == "one_many") ? instance.class.primary_key[0] : instance.class.foreign_key[0]
+        value = instance.method(instance.class.primary_key[0]).call
+        @db.query "UPDATE #{Ink::Model.str_to_tablename(firstclass.name)} SET #{secondclass.foreign_key[0]}=NULL WHERE #{key}=#{value};"
+      elsif type == "many_many"
+        tablename1 = Ink::Model.str_to_tablename(instance.class.name)
+        tablename2 = Ink::Model.str_to_tablename(link.name)
+        union_class = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
+        value = instance.method(instance.class.primary_key[0]).call
+        @db.query "DELETE FROM #{union_class} WHERE #{instance.class.foreign_key[0]}=#{value};"
+      end
+    end
+    
+    # Instance method
+    # 
+    # Attempt to create links of instance to the data inside value.
+    # link is the class of the related data, and type refers to the
+    # relationship type of the two. When one tries to insert an array
+    # for a x_one relationship, the last entry will be set.
+    # [param instance:] Instance of a class that refers to an existing database entry
+    # [param link:] the related class (not a String, but class reference)
+    # [param type:] relationship type
+    # [param value:] relationship data that was set, either a primary key value, or an instance, or an array of both
+    def create_all_links(instance, link, type, value)
+      to_add = Array.new
+      if value.is_a? Array
+        value.each do |v|
+          if v.instance_of? link
+            to_add.push(v.method(link.primary_key[0]).call)
+          else
+            to_add.push v
+          end
+        end
+      elsif value.instance_of? link
+        to_add.push(value.method(link.primary_key[0]).call)
+      else
+        to_add.push value
+      end
+      to_add.each do |fk|
+        self.create_link instance, link, type, fk
+      end
+    end
+    
+    # Instance method
+    # 
+    # Creates a link between instance and a link with primary fk.
+    # The relationship between the two is defined by type. one_one
+    # relationships are placing an additional call to delete_all_links
+    # that will remove conflicts.
+    # [param instance:] Instance of a class that refers to an existing database entry
+    # [param link:] the related class (not a String, but class reference)
+    # [param type:] relationship type
+    # [param value:] primary key of the relationship, that is to be created
+    def create_link(instance, link, type, fk)
+      if type == "one_one"
+        if (instance.class.name.downcase <=> link.name.downcase) < 0
+          re = self.find(link.name, "WHERE #{link.primary_key[0]}=#{fk};")[0]
+          self.delete_all_links re, instance.class, type
+        end
+        firstclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class : link
+        secondclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? link : instance.class
+        key = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class.primary_key[0] : link.primary_key[0]
+        value = instance.method(instance.class.primary_key[0]).call
+        fk_set = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? fk : value
+        value_set = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? value : fk
+        @db.query "UPDATE #{Ink::Model.str_to_tablename(firstclass.name)} SET #{secondclass.foreign_key[0]}=#{fk} WHERE #{key}=#{value};"
+      elsif type == "one_many" or type == "many_one"
+        firstclass = (type == "one_many") ? instance.class : link
+        secondclass = (type == "one_many") ? link : instance.class
+        key = (type == "one_many") ? instance.class.primary_key[0] : link.primary_key[0]
+        value = instance.method(instance.class.primary_key[0]).call
+        fk_set = (type == "one_many") ? fk : value
+        value_set = (type == "one_many") ? value : fk
+        @db.query "UPDATE #{Ink::Model.str_to_tablename(firstclass.name)} SET #{secondclass.foreign_key[0]}=#{fk_set} WHERE #{key}=#{value_set};"
+      elsif type == "many_many"
+        tablename1 = Ink::Model.str_to_tablename(instance.class.name)
+        tablename2 = Ink::Model.str_to_tablename(link.name)
+        union_class = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
+        value = instance.method(instance.class.primary_key[0]).call
+        @db.query "INSERT INTO #{union_class} (#{instance.class.foreign_key[0]}, #{link.foreign_key[0]}) VALUES (#{value}, #{fk});"
+      end
+    end
+    
+    # Class method
+    #
+    # Formats a Time object according to the SQL TimeDate standard
+    # [param date:] Time object
+    # [returns:] Formatted string
+    def self.format_date(date)
+      (date.instance_of? Time) ? date.strftime("%Y-%m-%d %H:%M:%S") : ""
+    end
+    
+  end
+  
+end

data/lib/webink/model.rb

@@ -0,0 +1,311 @@
+module Ink
+
+  # = Model class
+  #
+  # == Usage
+  #
+  # Models are usually derived from. So let's assume there is a
+  # class called Apple < Ink::Model
+  #
+  #   apple = Apple.new {:color => "red", :diameter => 4}
+  #
+  # The constructor checks, if there are class methods 'fields'
+  # and 'foreign' defined. If that check is positive, it will
+  # match the parameter Hash to the fields, that are set for
+  # the database, and thow an exception if fields is lacking
+  # an entry (excluded the primary key). The other case just
+  # creates an Apple with the Hash as instance variables.
+  #
+  #   puts apple.color
+  #
+  # This prints "red" to the stdout, since getter and setter
+  # methods are automatically added for either the Hash, or
+  # the fields and foreign keys.
+  #
+  #   apple.tree = nil
+  #   apple.save
+  #
+  # You can save your apple by using the save method. New instances
+  # will create a new row in the database, and update its primary
+  # key. Old instances just update the fields. Relationships, like
+  # in the sample below a tree, is set to nil by default, and therefore
+  # the save method will not touch relationships.
+  #
+  #   treeinstance.apple = [1,2,myapple]
+  #   treeinstance.save
+  #
+  # To insert relationship data, you can provide them by array, value
+  # or reference, so setting treeinstance.apple to 1 is allowed, also
+  # to myapple, or an array or a combination. An empty array [] will
+  # remove all references. This works both ways, just consider the
+  # relationship type, as an apple cannot have more than one tree.
+  #
+  #   treeinstance.delete
+  #
+  # The model provides a convenience method for deletion. It removes all
+  # references from relationships, but does not remove the relationships
+  # themselves, so you must fetch all related data, and delete them by
+  # 'hand' if you will.
+  #
+  #
+  # = Fields and foreign sample config
+  #
+  #   class Apple < Ink::Model
+  #     def self.fields
+  #       fields = {
+  #         :id => "PRIMARY KEY"
+  #         :color => [ "VARCHAR", "NOT NULL" ],
+  #         :diameter => [ "NUMERIC", "NOT NULL" ]
+  #       }
+  #       fields
+  #     end
+  #     def self.foreign
+  #       foreign = {
+  #         "Tree" => "one_many"
+  #       }
+  #       foreign
+  #     end
+  #   end
+  #
+  # Let's look at this construct.
+  # The constructor is inherited from Ink::Model, so are its
+  # methods. 'fields' defines a Hash of Arrays, that will
+  # create the Database table for us.
+  # 'foreign' handles the contraints to other classes, here
+  # it reads: one "Tree" has many Apples, other constructs
+  # could be: [one "Tree" has one Apple, many "Tree"s have
+  # many Apples, many "Tree"s have one Apple] => [one_one,
+  # many_many, many_one]
+  # Obviously the Tree class requires a foreign with "Apple"
+  # mapped to "many_one" to match this schema.
+  #
+  #
+  #
+  class Model
+    
+    # Constructor
+    #
+    # Keys from the data parameter will be converted into
+    # instance variables with getters and setters in place.
+    # The primary key has no setter, but adds a getter called
+    # pk for convenience.
+    # [param data:] Hash of String => Objects
+    def initialize(data)
+      if self.class.respond_to? :fields
+        self.class.fields.each do |k,v|
+          raise NameError.new("Model cannot use #{k} as field, it already exists") if self.class.respond_to? k or k.to_s.downcase == "pk"
+          raise LoadError.new("Model cannot be loaded, argument missing: #{k}") if not data[k.to_s] and self.class.primary_key[0] != k
+          entry = nil
+          if data[k.to_s].is_a? String
+            entry = data[k.to_s].gsub(/'/, '&#39;')
+          elsif data[k.to_s].is_a? Numeric
+            entry = data[k.to_s]
+          else
+            entry = "\'#{data[k.to_s]}\'"
+          end
+          instance_variable_set("@#{k}", entry)
+          
+          self.class.send(:define_method, k) do
+            instance_variable_get "@#{k}"
+          end
+          if self.class.primary_key[0] != k
+            self.class.send(:define_method, "#{k}=") do |val|
+              if val.is_a? String
+                val = val.gsub(/'/, '&#39;')
+              elsif val.is_a? Numeric
+                val = val
+              else
+                val = "\'#{val}\'"
+              end
+              instance_variable_set "@#{k}", val
+            end
+          else
+            self.class.send(:define_method, "pk") do
+              instance_variable_get "@#{k.to_s.downcase}"
+            end
+          end
+        end
+        if self.class.respond_to? :foreign
+          self.class.foreign.each do |k,v|
+            raise NameError.new("Model cannot use #{k} as foreign, it already exists") if self.class.respond_to? k.to_sym or k.downcase == "pk"
+            instance_variable_set "@#{self.class.str_to_tablename(k)}", nil
+            self.class.send(:define_method, k.downcase) do
+              instance_variable_get "@#{k.downcase}"
+            end
+            self.class.send(:define_method, "#{k.downcase}=") do |val|
+              instance_variable_set "@#{k.downcase}", val
+            end
+          end
+        end
+      else
+        data.each do |k,v|
+          instance_variable_set "@#{k}", (v.is_a?(Numeric)) ? v : "\'#{v}\'"
+        end
+      end
+    end
+    
+    # Instance method
+    #
+    # Save the instance to the database. Set all foreign sets to
+    # nil if you do not want to change them. Old references are
+    # automatically removed.
+    def save
+      raise NotImplementedError.new("Cannot save to Database without field definitions") if not self.class.respond_to? :fields
+      string = Array.new
+      keystring = Array.new
+      valuestring = Array.new
+      fields = self.class.fields
+      pkvalue = nil
+      for i in 0...fields.keys.length
+        k = fields.keys[i]
+        value = instance_variable_get "@#{k}"
+        value = "NULL" if not value
+        if k != self.class.primary_key[0]
+          string.push "`#{k}`=#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
+          keystring.push "`#{k}`"
+          valuestring.push "#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
+        else
+          pkvalue = "WHERE `#{self.class.primary_key[0]}`=#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
+        end
+      end
+      if pkvalue
+        response = Ink::Database.database.find self.class.name, pkvalue
+        if response.length == 1
+          Ink::Database.database.query "UPDATE #{Ink::Model.str_to_tablename(self.class.name)} SET #{string * ","} #{pkvalue}"
+        elsif response.length == 0
+          Ink::Database.database.query "INSERT INTO #{Ink::Model.str_to_tablename(self.class.name)} (#{keystring * ","}) VALUES (#{valuestring * ","});"
+          pk = Ink::Database.database.last_inserted_pk
+          instance_variable_set "@#{self.class.primary_key[0]}", pk.is_a?(Numeric) ? pk : "\'#{pk}\'" if pk
+        end
+      end
+      
+      if self.class.respond_to? :foreign
+        self.class.foreign.each do |k,v|
+          value = instance_variable_get "@#{self.class.str_to_tablename(k)}"
+          if value
+            Ink::Database.database.delete_all_links self, Ink::Model.classname(k), v
+            Ink::Database.database.create_all_links self, Ink::Model.classname(k), v, value
+          end
+        end
+      end
+    end
+    
+    # Instance method
+    # 
+    # Deletes the data from the database, essentially making the instance
+    # obsolete. Disregard from using the instance anymore.
+    # All links between models will be removed also.
+    def delete
+      raise NotImplementedError.new("Cannot delete from Database without field definitions") if not self.class.respond_to? :fields
+      if self.class.respond_to? :foreign
+        self.class.foreign.each do |k,v|
+          Ink::Database.database.delete_all_links self, Ink::Model.classname(k), v
+        end
+      end
+      
+      pkvalue = instance_variable_get "@#{self.class.primary_key[0]}"
+      Ink::Database.database.remove self.class.name, "WHERE `#{self.class.primary_key[0]}`=#{(pkvalue.is_a?(Numeric)) ? pkvalue : "\'#{pkvalue}\'"};"
+    end
+    
+    # Class method
+    # 
+    # This will create SQL statements for creating the
+    # database tables. 'fields' method is mandatory for
+    # this, and 'foreign' is optional.
+    # [returns:] Array of SQL statements
+    def self.create
+      result = Array.new
+      raise NotImplementedError.new("Cannot create a Database without field definitions") if not self.respond_to? :fields
+      
+      string = "CREATE TABLE #{Model::str_to_tablename(self.name)} ("
+      mfk = self.foreign_key
+      fields = self.fields
+      for i in 0...fields.keys.length
+        k = fields.keys[i]
+        string += "`#{k}` #{fields[k]*" "}" if k != self.primary_key[0]
+        string += "#{Ink::Database.database.primary_key_autoincrement(k)*" "}" if k == self.primary_key[0]
+        string += "," if i < fields.keys.length - 1
+      end
+      
+      if self.respond_to? :foreign
+        foreign = self.foreign
+        for i in 0...foreign.keys.length
+          k = foreign.keys[i]
+          v = foreign[k]
+          fk = Model::classname(k).foreign_key
+          string += ",`#{fk[0]}` #{fk[1]}" if fk.length > 0 and (v == "one_many" or (v == "one_one" and (self.name <=> k) < 0))
+          
+          if mfk.length > 0 and fk.length > 1 and v == "many_many" and (self.name <=> k) < 0
+            result.push "CREATE TABLE #{Model::str_to_tablename(self.name)}_#{Model::str_to_tablename(k)} (#{Ink::Database.database.primary_key_autoincrement*" "}, `#{mfk[0]}` #{mfk[1]}, `#{fk[0]}` #{fk[1]});"
+          end
+        end
+      end
+      string += ");"
+      result.push string
+      result
+    end
+    
+    # Class method
+    # 
+    # This will check the parent module for existing classnames
+    # that match the input of the str parameter.
+    # [param str:] some string
+    # [returns:] valid classname or nil
+    def self.str_to_classname(str)
+      ((Module.const_get str.capitalize).is_a? Class) ? str.capitalize : nil
+    end
+    
+    # Class method
+    # 
+    # This will check the parent module for existing classnames
+    # that match the input of the str parameter. Once found, it
+    # converts the string into the matching tablename.
+    # [param str:] some string
+    # [returns:] valid tablename or nil
+    def self.str_to_tablename(str)
+      ((Module.const_get str.capitalize).is_a? Class) ? str.downcase : nil
+    end
+    
+    # Class method
+    # 
+    # This will check the parent module for existing classnames
+    # that match the input of the str parameter. Once found, it
+    # returns the class, not the string of the class.
+    # [param str:] some string
+    # [returns:] valid class or nil
+    def self.classname(str)
+      ((Module.const_get str.capitalize).is_a? Class) ? (Module.const_get str.capitalize) : nil
+    end
+    
+    # Class method
+    #
+    # This will find the primary key, as defined in the fields class
+    # method.
+    # [returns:] Array of the form: key name, key type or empty
+    def self.primary_key
+      if self.respond_to? :fields
+        pk = nil
+        pktype = nil
+        self.fields.each do |k,v|
+          if v.is_a?(String) and v == "PRIMARY KEY"
+            pk = k
+            pktype = Ink::Database.database.primary_key_autoincrement(k)[1]
+          end
+        end
+        return [pk, pktype]
+      end
+      return []
+    end
+    
+    # Class method
+    #
+    # This will create the foreign key from the defined primary key
+    # [returns:] Array of the form: key name, key type or empty
+    def self.foreign_key
+      pk = self.primary_key
+      return (pk) ? ["#{self.str_to_tablename(self.name)}_#{pk[0]}", pk[1]] : []
+    end
+    
+  end
+  
+end