hypersonicplus 0.0.0

data/lib/hdb/hdbi.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+require 'dbi'
+require 'hdb/hdb'
+
+class HDBI < HDB
+
+  def initialize(host, port, dbname, user, password, timezone, connectionName, connector = "Pg")
+
+    super(host, port, dbname, user, password, timezone, connectionName, connector)
+    @connector = connector
+    @sth = nil
+
+  end
+ 
+  def connect()
+
+    @connection = DBI.connect("dbi:#{@connector}:#{@dbname}:#{@host}", @user, @password)
+    hl << "Server version: #{self.execute("SHOW server_version").firstData.to_s}"
+    self.execute("SET TIME ZONE '#{@timezone}'") if @timezone
+    return @connection
+
+  end
+
+  def disconnect()
+
+    @connection.disconnect()
+    @connection = nil 
+
+  end
+  
+  def _execute(queryStr = self.queryStr) 
+
+    @sth = @connection.execute(queryStr)
+    result = @sth.fetch_all
+    @resultTable = HFieldTable.new()
+    self.fieldNameList().each { |fieldName| @resultTable.addFieldName(fieldName) }
+    @resultTable.makeCaption()
+    result.each_with_index do |row, i|  
+      row.each_with_name do |fieldValue, fieldName|
+        @resultTable.setDataByFieldName(i, fieldName, fieldValue)
+      end
+    end
+    @sth.finish
+    @sth = nil
+    return self
+
+  end
+  
+  def fieldNameList()
+
+    fieldList = HList.new()
+    
+    @sth.column_names.each { |fieldName| fieldList << fieldName }
+    
+    return fieldList
+
+  end
+ 
+  def rowsAffected
+    return @sth.rows # rows affected
+  end
+end
+

data/lib/hdb/hdbi_test.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+require 'hdb/hdbi.rb' 
+
+class HDBI
+
+  def self.testx
+    resultTable = hdb.select([:id, :name]).from(:recipe_types).where(["id > 0", "id < 20000"]).orderBy([:id, :name]).execute
+    resultTable.show
+  end
+  
+  def self.testxx
+    resultTable = hdb("quickorder_pg").select([:id, :name]).from(:recipe_types).where(["id > 0", "id < 20000"]).orderBy([:id, :name]).execute
+    resultTable.show
+  end
+
+  def self.testmysql
+    id = hdb("quickorder").insert(:city_table, {name: "Wien"})
+    puts "id: #{id}"
+    resultTable = hdb("quickorder").select([:id, :name]).from(:city_table).where(["id > 0", "id < 20"]).orderBy([:id, :name]).execute
+    resultTable.show
+  end
+
+  def self.test
+  end
+
+
+  def self.test0
+
+    hdb = HDB.new('localhost', '5432', 'quickorder', 'quickorder', 'quickorder')
+    hdb.openConnection()
+    resultTable = hdb.select([:id, :name]).from(:cookbook).where(["id > 0", "id < 200"]).orderBy([:id, :name]).execute
+    resultTable = hdb.select("id, name").from("cookbook").where("id > 0 and id < 200").execute
+    hdb.show()
+    resultTable = hdb.select([:id, :name]).from(:cookbook).where(["id > 0", "id < 200"], "or").orderBy([:id, :name]).execute(pageSize: 10, page: 2)
+    hdb.toSqlTable().show()
+    id = hdb.insert(:recipe_types, {name: "'nome"})
+    p "delete: " + hdb.delete(:recipe_types, {id: id, name: '10'}).to_s
+    hdb.select(:name).from(:recipe_types).execute
+    hdb.show()
+    hdb.closeConnection
+
+  end
+
+
+  def self.test1
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    sth = dbh.execute("select * from cookbook")
+    p sth.column_names
+    sth.fetch do |row|
+      #p row['name'] # or row.by_field("name")
+      #p row[3]      # or row.by_index(3)
+      row.each_with_name do |fieldValue, fieldName|
+        p "  #{fieldName}: #{fieldValue}"
+      end
+      p "======================="
+    end
+    sth.finish
+
+  end
+
+  def self.test2
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    sth = dbh.prepare("select * from cookbook where id = ?")
+    sth.execute(1)
+    p sth.column_names
+    sth.fetch do |row|
+      #p row['name'] # or row.by_field("name")
+      #p row[3]      # or row.by_index(3)
+      row.each_with_name do |fieldValue, fieldName|
+        p "  #{fieldName}: #{fieldValue}"
+      end
+      p "======================="
+    end
+    sth.finish
+
+  end
+
+
+  # finish isn't required
+  def self.test3
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    rows = dbh.select_all("select * from cookbook") # con select_all o select_one non e' necessario finish
+    rows.each do |row|
+      row.each_with_name do |fieldValue, fieldName|
+        p "  #{fieldName}: #{fieldValue}"
+      end
+      p "======================="
+    end
+
+  end
+
+
+  def self.test4
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    dbh.do("insert into recipe_types(name, position, department) values(?, ?, ?)", 'hypersonic', 1, nil)
+
+  end
+
+  def self.test5
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    sth = dbh.prepare("insert into recipe_types(name, position, department) values(?, ?, ?)")
+    sth.execute('hypersonic', 1, nil)
+    sth.finish
+
+  end
+
+  def self.test6
+
+    dbh = DBI.connect("dbi:Pg:quickorder:localhost", "quickorder", "quickorder")
+    sth = dbh.execute("select * from cookbook")
+    rows = sth.fetch_all
+
+    printf "Number of rows affected: %d\n", sth.rows
+    printf "Number of columns: %d\n", sth.column_names.size
+
+    rows.each do |row|
+      row.each_with_name do |fieldValue, fieldName|
+        p "  #{fieldName}: #{fieldValue}"
+      end
+      p "======================="
+    end
+    sth.finish
+
+  end
+
+end
+
+

data/lib/hdb/hfield.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+=begin
+FIELDS_TO_PGTYPES = {
+    fields.boolean: 'bool',
+    fields.integer: 'int4',
+    fields.text: 'text',
+    fields.html: 'text',
+    fields.date: 'date',
+    fields.datetime: 'timestamp',
+    fields.binary: 'bytea',
+    fields.many2one: 'int4',
+    fields.serialized: 'text',
+}
+=end
+
+class HField < Hash
+
+  def initialize(args)
+    args.each { |key, value| self[key] = value }
+  end
+
+  def defaultValue()
+    
+    case self[:type]
+    when "char"
+      return 'true'
+    when "text"
+      return ''
+    when "integer"
+      return 0
+    when "float"
+      return 0
+    when "date"
+      return '' 
+    when "dateTime"
+      return ''
+    when "binary"
+      return ''
+    when "selection"
+      return ''
+    when "boolean"
+      return 'true'
+    else
+      return nil
+    end
+
+  end
+
+  def self.autoComplete(modelName, fieldName, args = {})
+    
+    return args if args[:type] != "automatic"
+    
+    if fieldName =~ /^(\w+)_id$/
+      return self.manyToOne($1, args)
+    elsif fieldName =~ /^(\w+)_table$/
+      return self.oneToMany($1, "#{modelName}_id", args)
+    elsif fieldName =~ /^(\w+)_join$/
+      return self.manyToMany($1, "#{modelName}_#{fieldName}", "#{modelName}_id", "#{$1}_id", args)
+    elsif fieldName =~ /^(\w+)_virtual$/
+      return self.virtual($1, nil, args)
+    end
+
+    return HField.new(args)
+
+  end
+  
+  def self.automatic(args = {})
+    args[:type] = "automatic"
+    return HField.new(args)
+  end
+  
+  def self.magic(args = {})
+    return self.automatic(args)
+  end
+
+  def self.char(args = {})
+    args[:type] = "char"
+    args[:default] = '' unless args[:default]
+    return HField.new(args)
+  end
+
+  def self.text(args = {})
+    args[:type] = "text"
+    args[:default] = '' unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.integer(args = {})
+    args[:type] = "integer"
+    args[:default] = 0 unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.float(args = {})
+    args[:type] = "float"
+    args[:default] = 0 unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.date(args = {})
+    args[:type] = "date"
+    args[:default] = '' unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.dateTime(args = {})
+    args[:type] = "datetime"
+    return HField.new(args)
+  end
+  
+  def self.binary(args = {})
+    args[:type] = "binary"
+    args[:default] = '' unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.selection(args = {})
+    args[:type] = "selection"
+    return HField.new(args)
+  end
+  
+  def self.boolean(args = {})
+    args[:type] = "boolean"
+    args[:default] = false unless args[:default]
+    return HField.new(args)
+  end
+  
+  def self.oneToOne(modelName, args = {})
+    args[:modelNameReference] = modelName
+    #args[:constraint] = 'NOT NULL'
+    args[:onDelete] = 'CASCADE' # CASCADE or RESTRICT
+    args[:onUpdate] = 'CASCADE'
+    args[:type] = "oneToOne"
+    return HField.new(args)
+  end
+  
+  def self.oneToMany(modelName, referenceFieldName, args = {})
+    args[:modelNameReference] = modelName
+    args[:referenceFieldName] = referenceFieldName
+    args[:type] = "oneToMany"
+    return HField.new(args)
+  end
+  
+  def self.manyToOne(modelName, args = {})
+    args[:modelNameReference] = modelName
+    args[:onDelete] = 'CASCADE'
+    args[:onUpdate] = 'CASCADE'
+    #args[:constraint] = 'NOT NULL'
+    args[:type] = "manyToOne"
+    return HField.new(args)
+  end
+  
+  def self.manyToMany(modelName, joinTable, referenceFieldName, referenceFieldName2, args = {})
+    args[:modelNameReference] = modelName
+    args[:joinTable] = joinTable
+    args[:referenceFieldName] = referenceFieldName
+    args[:referenceFieldName2] = referenceFieldName2
+    #args[:constraint] = 'NOT NULL'
+    args[:type] = "manyToMany"
+    return HField.new(args)
+  end
+
+  def self.virtual(functionName = nil, object = nil, args = {}, &block)
+    args[:object] = object
+    args[:functionName] = functionName
+    args[:type] = "virtual"
+    args[:block] = block
+    return HField.new(args)
+  end
+  
+  def self.primaryKey(args = {})
+    args[:type] = 'integer'
+    args[:system] = true
+    args[:constraint] = 'SERIAL PRIMARY KEY'
+    return HField.new(args)
+  end
+
+end
+

data/lib/hdb/hmysql.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'mysql'
+require 'hdb/hdb'
+
+class Hash
+
+  def join(separator)
+
+    arr = []
+    self.each do |key, value|
+      arr << "#{key} = #{value}"
+    end
+    return arr.join(separator)
+
+  end
+end
+
+class Array
+
+  def hjoin(separator, quoteChar = '"')
+
+    arr = []
+    self.each { |value| arr << "#{value}" }
+    return arr.join(separator)
+  end
+
+end
+
+class HMySql < HDB
+  
+  def initialize(host, port, dbname, user, password, timezone, connectionName)
+
+    super(host, port, dbname, user, password, timezone, connectionName, "hmysql")
+    @result = nil
+
+  end
+
+  def connect()
+
+    @connection = Mysql.new(@host, @user, @password, @dbname, @port.to_i)
+    #hl << "Server version: #{self.execute("SHOW server_version").dataByFieldIndex(0,0).to_s}"
+    self.execute("SET time_zone = '#{@timezone}'") if @timezone
+    return @connection
+
+  end
+
+  def disconnect()
+
+    @connection.close()
+    @connection = nil
+
+  end
+
+  def _execute(queryStr = self.queryStr) 
+
+    @result = @connection.query(queryStr)
+    
+    return self unless @result
+    
+    @resultTable = HFieldTable.new()
+    self.fieldNameList().each { |fieldName| @resultTable.addFieldName(fieldName) }
+    @resultTable.makeCaption()
+    r = 0
+    @result.each do |row|  
+      row.each_with_index do |fieldValue, c|
+        @resultTable.setDataByFieldIndex(r, c, fieldValue.to_s)
+      end
+      r += 1
+    end
+
+    return self
+
+  end
+  
+  def fieldNameList()
+
+    fieldList = HList.new()
+    
+    @result.fetch_fields.each { |field| fieldList << field.name }
+    
+    return fieldList
+
+  end
+  
+  def insert(tableName, values)
+
+    self.execute("INSERT INTO #{tableName} #{self.insertValues(values)}")
+    return @connection.insert_id
+
+  end
+
+  def rowsAffected
+    return @connection.affected_rows()
+  end
+
+
+end
+