shalmaneser 0.0.1.alpha

data/lib/rosy/DBMySQL.rb

@@ -0,0 +1,146 @@
+
+# DBMysql: a subclass of DBWrapper.
+#
+# Use a MySQL server to access a database.
+# Use the Ruby mysql interface package for that.
+
+require 'mysql'
+
+
+require 'rosy/DBWrapper'
+
+#################
+class DBMySQLResult < DBResult
+  # initialize with the result of Mysql::query
+  # which is a MysqlResult object
+  #
+  # also remember the offset of the first row
+  # for reset()
+  def initialize(value)
+    super(value)
+    @row_first = @result.row_tell()
+  end
+
+  ###
+  # reset object such that each() can be run again
+  def reset()
+    @result.row_seek(@row_first)
+  end
+
+  ###
+  # column names: list of strings
+  def list_column_names()
+    current = @result.row_tell()
+    fields = @result.fetch_fields().map { |f|
+      f.name()
+    }
+    @result.row_seek(current)
+    return fields
+  end
+end
+
+
+#################
+class DBMySQL < DBWrapper
+  ###
+  # initialization: 
+  #
+  # open connection to MySQL server
+  def initialize(exp)  # RosyConfigData experiment file object
+    super(exp)
+    
+    @database = Mysql.real_connect(@exp.get('host'), @exp.get('user'), 
+                                   @exp.get('passwd'), @exp.get('dbname'))
+
+  end
+
+
+  ###
+  # make a table
+  #
+  # returns: nothing
+  def create_table(table_name, # string
+                   column_formats, # array: array: string*string [column_name,column_format]
+                   index_column_names, # array: string: column_name
+                   indexname)  # string: name of automatically created index column    
+
+    string = "CREATE TABLE #{table_name} (" +
+      "#{indexname} INT NOT NULL AUTO_INCREMENT"
+
+    # column declarations
+    unless column_formats.empty?
+      string << ", "
+      string << column_formats.map { |name, format| name.to_s + " " + format.to_s }.join(",")
+    end
+
+    # primary key
+    string << ", " + "PRIMARY KEY(#{indexname})"
+
+    # other keys
+    unless index_column_names.empty?
+      string << ", "
+      string << index_column_names.map { |name| "KEY(#{name})" }.join(",")
+    end
+    string << ");"
+
+    query_noretv(string)
+  end
+
+  ####
+  # querying the database:
+  # returns a DBResult object
+  def query(query)
+    result = @database.query(query)
+    if result
+      return DBMySQLResult.new(result)
+    else
+      return nil
+    end
+  end
+
+  ####
+  # querying the database:
+  # no result value
+  def query_noretv(query)
+    @database.query(query)
+    return nil
+  end
+
+  ###
+  # list all tables in the database
+  #
+  # array of strings
+  def list_tables()
+    return @database.list_tables()
+  end
+
+
+  #####
+  # list_column_formats
+  #
+  # list column names and column types of this table
+  #
+  # returns: array:string*string, list of pairs [column name, column format]
+  def list_column_formats(table_name)
+    retv = Array.new
+    @database.query("DESCRIBE #{table_name}").each_hash { |field|
+      retv << [field["Field"], field["Type"]]
+    }
+    return retv
+  end
+
+  ####
+  # num_rows
+  #
+  # determine the number of rows in a table
+  # returns: integer or nil
+  def num_rows(table_name)
+    @database.query("SHOW TABLE STATUS").each_hash { |hash|
+      if hash["Name"] == table_name
+        return hash["Rows"]
+      end
+    }
+    return nil
+  end
+
+end

data/lib/rosy/DBSQLite.rb

@@ -0,0 +1,280 @@
+# DBSQLite: a subclass of DBWrapper.
+#
+# Use SQLite to access a database.
+# Use the Ruby sqlite3 interface package for that.
+
+require 'sqlite3'
+require 'tempfile'
+
+require "DBWrapper"
+
+#################
+class DBSQLiteResult < DBResult
+  # initialize with the result of SQLite::execute()
+  # which returns an array of rows
+  # Each row is an array
+  # but additionally has attributes
+  # - fields: returns an array of strings, the column names
+  # - types: returns an array of strings, the column types
+  def initialize(value)
+    super(value)
+    @counter = 0
+  end
+
+  ###
+  # column names: list of strings
+  def list_column_names()
+    return @result.columns
+  end
+
+  # number of rows: returns an integer
+  def num_rows()
+    # remember where we were in iterating over items
+    tmp_counter = @counter
+    
+    # reset, and iterate over all rows to count
+    reset()
+    retv = 0
+    each { |x| retv += 1}
+    
+    # return to where we were in iterating over items
+    reset()
+    while @counter < tmp_counter
+      @result.next()
+      @counter += 1
+    end
+
+    # and return the number of rows
+    return retv
+  end
+
+
+  # yields each row as an array of values
+  def each()
+    @result.each { |row| 
+      @counter += 1
+      yield row.map { |x| x.to_s() }
+    }
+  end
+
+  # yields each row as a hash: column name=> column value
+  def each_hash()
+    @result.each { |row| 
+      @counter += 1
+
+      row_hash = Hash.new()
+      row.fields.each_with_index { |key, index|
+        row_hash[key] = row[index].to_s()
+      }
+      yield row_hash
+    }
+  end
+
+
+  ###
+  # reset such that each() can be run again on the result object
+  def reset()
+    @result.reset()
+    @counter = 0
+  end
+
+  # free object
+  def free()
+    @result.close()
+  end
+
+  # returns row as an array of column contents
+  def fetch_row()
+    @counter += 1
+    return @result.next()
+  end
+end
+
+#################
+class DBSQLite < DBWrapper
+
+  ###
+  # initialization: 
+  #
+  # open database file according to the given identifier
+  def initialize(exp,  # RosyConfigData experiment file object
+                 dir = nil,  # string: directory for Shalmaneser internal data, ends in "/"
+                 identifier = nil) # string: identifier to use for the database
+    super(exp)
+
+    # dir and identifier may be nil, if we're only opening this object
+    # in order to make temp databases
+    if dir and identifier
+      @database = SQLite3::Database.new(dir + identifier.to_s + ".db")
+    else
+      @database = nil
+    end
+
+    # temp file for temp database
+    @tf = nil
+  end
+
+  ###
+  # make a table
+  #
+  # returns: nothing
+  def create_table(table_name, # string
+                   column_formats, # array: array: string*string [column_name,column_format]
+                   index_column_names, # array: string: column_name
+                   indexname)  # string: name of automatically created index column   
+
+    # primary key and auto-increment column 
+    string = "CREATE TABLE #{table_name} (" +
+      "#{indexname} INTEGER PRIMARY KEY"
+
+    # column declarations
+    unless column_formats.empty?
+      string << ", "
+      string << column_formats.map { |name, format| 
+        # include other keys
+        if index_column_names.include? name
+          name.to_s + " KEY " + format.to_s
+        else
+          name.to_s + " " + format.to_s 
+        end          
+      }.join(",")
+    end
+    string << ");"
+
+    query_noretv(string)
+  end
+
+  ###
+  # remove a table
+  def drop_table(table_name)
+    query_noretv("DROP TABLE " + table_name)
+  end
+
+  ###
+  def query(query)
+    if @database
+      return DBSQLiteResult.new(@database.query(query))
+    else
+      return nil
+    end
+  end
+
+  ####
+  # querying the database:
+  # no result value
+  def query_noretv(query)
+    if @database
+      @database.execute(query)
+    end
+    return nil
+  end
+
+  ###
+  # list all tables in the database
+  #
+  # array of strings
+  def list_tables()
+    if @database
+      return @database.execute("select name from sqlite_master;").map { |t|
+        t.to_s()
+      }
+    else
+      return nil
+    end
+  end
+
+  #####
+  # list_column_formats
+  #
+  # list column names and column types of this table
+  #
+  # returns: array:string*string, list of pairs [column name, column format]
+  def list_column_formats(table_name)
+    unless @database
+      return nil
+    end
+
+    table_descr = @database.execute("select * from sqlite_master where name=='#{table_name}';")
+      # this is an array of pieces of table description.
+      # the piece in the column called 'sql' is the 'create' statement. 
+    # get the 'create' statement
+    begin
+      field_names = table_descr[0].fields
+    rescue
+      $stderr.puts "SQLite error: could not read description of table #{table_name}"
+      exit 1
+    end
+    create_index = (0..field_names.length()).detect { |ix| field_names[ix] == 'sql' }
+
+    # try to parse column names out of the 'create' statement
+    if table_descr[0][create_index] =~ /^\s*create table \S+\s*\((.*)\)\s*$/i
+      # we now have something of shape ' a key varchar2(30), b varchar2(30)'
+      # split at the comma, remove whitespace at beginning and end
+      # then split again to get pairs [column name, column format]
+      return $1.split(",").map { |col_descrip|
+        pieces = col_descrip.strip().split().reject { |entry| 
+          entry =~ /^key$/i or  entry =~ /^primary$/i 
+        }
+        if pieces.length() > 2
+          $stderr.puts "Warning: problematic column format in #{col_descrip}, may be parsed wrong."
+        end
+        pieces
+      }
+    else
+      $stderr.puts "SQLite error: cannot read column names"
+      exit 1
+    end
+  end
+
+  ####
+  # num_rows
+  #
+  # determine the number of rows in a table
+  # returns: integer or nil
+  def num_rows(table_name)
+    unless @database
+      return nil
+    end
+
+    rows_s = @database.get_first_value( "select count(*) from #{table_name}" )
+    if rows_s
+      return rows_s.to_i()
+    else
+      return nil
+    end
+  end
+
+  ####
+  # make a temporary table: make a table in a new, temporary file
+  #
+  # returns: DBWrapper object (or object of current subclass)
+  # that has the @table_name attribute set to the name of a temporary DB
+  #
+  # same as in superclass
+  #
+  #   def make_temp_table(column_formats, # array: string*string [column_name,column_format]
+  #                       index_column_names, # array: string: column_name
+  #                       indexname)  # string: name of autoincrement primary index
+  
+  #     temp_obj = self.clone()
+  #     temp.initialize_temp_table(column_formats, index_column_names, indexname)
+  #     return temp_obj
+  #   end
+
+  def drop_temp_table()
+    @tf.close(true)
+    @database = nil
+  end
+
+  ##############################
+  protected
+
+  def initialize_temp_table(column_formats, index_column_names, indexname)
+    @table_name = "temptable"
+    @tf = Tempfile.new("temp_table")
+    @tf.close()
+    @database = SQLite3::Database.new(@tf.path())
+    create_table(@table_name, column_formats, index_column_names, indexname)
+  end
+
+end

data/lib/rosy/DBTable.rb

@@ -0,0 +1,239 @@
+# class DBTable
+# KE, SP 27.1.05
+#
+# Manages one table in a (given) SQL database
+# Doesn't know anything about the ROSY application
+# Just creating a table, changing the table, and accessing it.
+#
+
+require "common/SQLQuery"
+require "common/RosyConventions"
+
+class DBTable
+  attr_reader :index_name, :table_name
+
+  #####
+  # new
+  #
+  # creates the table for this object.
+  # The name of the table (given as parameter) can be new, in which caes the table
+  # is created, or old, in which case we check whether its format matches the format
+  # given in the parameters.
+  #
+  # The table format is given in the form of column formats (column names and column formats,
+  # formats are the usual SQLy things). Additionally, a subset of the column names can be
+  # designated index columns, which means that the table is indexed (and can be searched quickly)
+  # for them.
+  #
+  # DBTable internally constructs a "Primary index" feature that is called "XXindexXX" (autoincrement column)
+  #
+  # For all columns that are added later using add_columns, DBTable adds a prefix to the column names;
+  # these columns are not checked against the column_formats when opening an existing table;
+  # this can be used to store experiment-specific data.
+
+  def initialize(db_obj, # DBWrapper object
+		 table_name, # string: name of DB table (existing/new)
+		 mode,       # new: starts new DB table, removes old if it exists. open: reopens existing DB table
+		 hash={})    # hash: parameter name => parameter value, depending on mode
+                             # mode= new needs: 
+                             #  'col_formats': array:array len 2: string*string, [column_name, column_format] 
+                             #  'index_cols':  array:string: column_names that should be used to index the table
+                             #  'addcol_prefix': string: prefix for names of additional columns
+                             # mode='open' needs:
+                             #  'col_formats': array: string*string: column names/formats
+                             #               May be nil, in that case column name match isn't tested
+
+    @index_name = "XXindexXX"
+    @db_obj = db_obj
+    @table_name = table_name
+
+    case mode
+    when 'new'
+      ###
+      # open new database
+
+      # sanity check: exactly the required parameters present?
+      unless hash.keys.sort == ['addcol_prefix', 'col_formats', 'index_cols']
+	raise "Expecting hash parameters 'addcol_prefix', 'col_formats', 'index_cols'.\n" +
+	  "I got: " + hash.keys.join(", ")
+      end
+
+      # sanity check: main index column name should be unique
+      all_column_names = hash['col_formats'].map { |name, format| name}
+      if all_column_names.include? @index_name
+	raise "[DBTable] You used the reserved name #{@index_name} as a column name. Please don't do that!"
+      end
+
+      # sanity check: index_column_names should be included in column_names
+      hash['index_cols'].each { |name| 
+	unless all_column_names.include? name
+	  raise "[DBTable] #{name} is in the list of index names, but it isn't in the list of column names."
+	end
+      }
+
+      # does a table with name table_name exist? if so, remove it
+      if @db_obj.list_tables().include? table_name
+	# this table exists
+	# remove old table
+	@db_obj.drop_table(table_name)
+      end
+
+      @db_obj.create_table(table_name,hash['col_formats'],
+                           hash['index_cols'], @index_name)
+    when 'open'
+
+      ###
+      # open existing database table
+
+      # sanity check: exactly the required parameters present?
+      hash.keys.each { |key|
+        unless ['addcol_prefix', 'col_names'].include? key
+          raise "Expecting hash parameters 'addcol_prefix', 'col_names'.\n" +
+          "I got: " + hash.keys.join(", ")
+        end
+      }
+      # sanity check: main index column name should be unique
+      if hash['col_names'] and hash['col_names'].include? @index_name
+	raise "[DBTable] You used the reserved name #{@index_name} as a column name. Please don't do that!"
+      end
+
+
+      # does a table with name table_name exist?
+      unless @db_obj.list_tables().include? table_name
+	raise "[DBTable] Sorry, I cannot find a database table named #{table_name}."
+      end
+
+      # check if all column formats match
+
+      if hash['col_names']
+
+        existing_fields = @db_obj.list_column_names(table_name).reject { |col|
+          col =~ /^#{hash["addcol_prefix"]}/ or
+          col == @index_name
+        }
+
+        unless existing_fields.sort() == hash["col_names"].sort()
+          raise "[DBTable] Column names in the DB table #{table_name}\n" + 
+                "don't match feature specification in the experiment file.\n" + 
+                "Table:\n\t" + existing_fields.sort.join(", ") +
+                 "\n\nExp. file:\n\t" + hash["col_names"].sort.join(", ")
+        end
+
+      else
+        # no column names given, no check of column formats
+      end
+
+    else
+      raise "Parameter 'mode' needs to be either 'new' or 'open'! I got " + mode.to_s
+    end
+  end
+
+  #####
+  # list_column_names
+  #
+  # list column names of this table
+  #
+  # returns: array:string, list of column names
+  def list_column_names()
+    return @db_obj.list_column_names(@table_name)
+  end
+
+  #####
+  # list_column_formats
+  #
+  # list column names and column types of this table
+  #
+  # returns: array:string*string, list of pairs [column name, column format]
+  def list_column_formats()
+    return @db_obj.list_column_formats(@table_name)
+  end
+
+  #####
+  # change_format_add_columns
+  #
+  # adds one or more columns to the table managed by this object
+  # columns are given by their names and formats, as above
+  #
+  # returns: nothing
+  def change_format_add_columns(column_formats) # array: string*string [column_name,column_format]
+
+    if column_formats.nil? or column_formats.empty?
+      raise "Need nonempty column_formats list"
+    end
+    
+    column_formats.each {|col_name,col_format|
+      unless col_name =~ /^#{@addcol_prefix}/
+	raise "Columns that are added need to have prefix #{@addcol_prefix}!" 
+      end
+    }
+
+    execute_command(SQLQuery.add_columns(@table_name, column_formats))
+  end
+
+  #####
+  # change_format_remove_column
+  #
+  # removes one column from the table managed by this object
+  #
+  # returns: nothing
+  def change_format_remove_column(column_name) # string:name of the column to remove
+    unless list_column_names(@table_name).include? column_name
+      $stderr.puts "WARNING: Cannot remove column #{column_name}: I don't have it"
+      return
+    end
+
+    execute_command("ALTER TABLE #{@table_name} DROP COLUMN #{column_name}")
+  end
+
+  
+  #####
+  # insert_row
+  #
+  # inserts a new row into the table and fills cells with values, as specified
+  # by the column_value_pairs
+  #
+  # returns: nothing
+  def insert_row(column_value_pairs) # array: string*Object [column_name,column_value]
+    if column_value_pairs.nil? or column_value_pairs.empty?
+      raise "Need nonempty column_value_pairs list"
+    end
+    execute_command(SQLQuery.insert(@table_name,column_value_pairs))
+  end
+
+  #####
+  # update_row
+  #
+  # update column values for a given row which is identified
+  # via its (autoincrement) index
+  #
+  # returns: nothing
+  def update_row(index, # index, content of autoincrement column
+		 column_value_pairs) # array: string*Object [column_name, column_value]
+
+    if column_value_pairs.nil? or column_value_pairs.empty?
+      raise "Need nonempty column_value_pairs list"
+    end
+    execute_command(SQLQuery.update(@table_name,
+				    column_value_pairs, 
+				    [ValueRestriction.new(@index_name, index)]))
+  end
+
+
+  ####
+  private
+
+  ###
+  # execute_command:
+  # execute DB command
+  #
+  # returns nil: the commands in this package are all
+  # not of the kind that requires a return value
+  def execute_command(command)
+    begin
+      @db_obj.query_noretv(command)
+    rescue 
+      $stderr.puts "Error executing SQL query. Command was:\n" + command
+      exit 1
+    end
+  end
+end