hypersonic-plus 0.0.0

data/lib/hdatastructures/hspreadfieldtable.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+require "hdatastructures/hfieldtable"
+
+class HSpreadFieldTable < HFieldTable 
+ 
+  attr_accessor :decorator
+  attr_reader :summaryList
+
+  def initialize
+    super
+    @decorator = false
+    @summaryList = []
+  end
+
+  def addSummary(summaryName, summaryValue)
+
+    record = HRecord.new(summaryName)
+    record.setValue(summaryName)
+    record.set(:value, summaryValue)
+    @summaryList << record
+
+  end
+
+  def noname(data, value)
+    return data.class == HRecord ? data.dup.setValue(value) : value
+  end
+
+  def decorate(data, value, fieldName)
+    decorator = @fields[fieldName].decorator
+    value = decorator.gsub("§arg§", value) if (@decorator and decorator)
+    return self.noname(data, value)
+  end
+
+  def evalDataByFieldName(row, fieldName)
+    
+    value = self.valueByFieldName(row, fieldName)
+    return value if value.class == Fixnum 
+    value = value.gsub(/`([a-zA-Z_]+[a-zA-Z_0-9]*)/) { |var| self.evalDataByFieldName(row, $1) }
+    return eval(value)
+
+  end
+
+  def dataByFieldName(row, fieldName)
+    
+    value = data = super(row, fieldName)
+    value = data.value() if (data.class == HRecord)
+    return self.noname(data, self.evalDataByFieldName(row, fieldName)) if value.class == String and value.index('`')
+    return self.decorate(data, value, fieldName)
+ 
+  end
+ 
+  def showSummary()
+
+    @summaryList.each do |data|
+      if data 
+        print $hpformat % data.value()
+        print $hpformat % data.value(:value)
+      end
+    puts
+    end
+  end
+ 
+
+  def self.test()
+
+    fieldTable = HSpreadFieldTable.new()
+    fieldTable.addFieldName("quantity")
+    fieldTable.addFieldName("description")
+    fieldTable.addFieldName("price")
+    fieldTable.addFieldName("amount", false)
+    fieldTable.addFieldName("score")
+    fieldTable.addFieldName("other")
+
+    fieldTable.setFieldCaption("quantity", "Quantity")
+    fieldTable.setFieldCaption("description", "Description")
+    fieldTable.setFieldCaption("price", "Price")
+    fieldTable.setFieldCaption("amount", "Amount")
+    fieldTable.setFieldCaption("score", "Score")
+    fieldTable.setFieldCaption("other", "Other")
+    
+    fieldTable.setFieldFilter("price", 3)
+    fieldTable.setFieldFilter("score", HRecord.new(18))
+
+    fieldTable.setFieldDecorator("description", "Item: §arg§")
+
+    fieldTable.setFieldTotalizer("price", "P R I C E")
+    fieldTable.setFieldTotalizer("amount", "T O T A L")
+    fieldTable.setFieldTotalizer("score", "S C O R E")
+    fieldTable.addSummary("SUMMARY", "2.000 Euro")
+
+    for i in 0..5
+      (other = HRecord.new(i)).color = "green"
+      (amount = HRecord.new("`quantity * `price")).color = "yellow"
+      fieldTable.setIntoRecordByFieldName(i, "quantity", i)
+      fieldTable.setIntoRecordByFieldName(i, "description", "Product #{i}")
+      fieldTable.setIntoRecordByFieldName(i, "price", i)
+      fieldTable.setDataByFieldName(i, "amount", amount)
+      fieldTable.setIntoRecordByFieldName(i, "score", "`amount * 2")
+      fieldTable.setDataByFieldName(i, "other", other)
+    end
+
+    fieldTable.show()
+    fieldTable.allRows,fieldTable.allCols = true, true 
+    fieldTable.decorator = true
+    fieldTable.show()
+    fieldTable.showTotalizers()
+    fieldTable.showSummary()
+
+    return fieldTable
+
+  end
+
+  def self.test2
+    fieldTable = HSpreadFieldTable.test()
+    fieldTable.eachWithFieldName do |row|
+      row.each do |key, data|
+        p key, data
+      end
+      puts
+    end
+    return fieldTable
+  end
+
+end
+
+t1 = Time.now
+HSpreadFieldTable.test()
+#HSpreadFieldTable.test2()
+p "... msecs. #{((Time.now - t1) * 1000).round(2)}"

data/lib/hdb/hdataloader.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+require 'hdb/hdb'
+require "yaml"
+
+class HDataLoader 
+
+  def initialize(filename, connectionName = "default")
+    @filename = filename
+    @connectionName = connectionName
+  end
+
+
+  def load
+    
+    return unless File.file?(@filename)
+    @data = YAML.load_file(@filename)
+    oodb = HODB.new(connectionName: @connectionName)
+    @data.each do |modelName, record|
+      model = oodb.newHODB(modelName)
+      record.each do |recordName, recordValue|
+        model.create(recordValue)
+      end
+      model.writeAll
+    end
+  end
+
+
+  def recordGenerator(tableName, record, min, max, overwrite = false)
+
+    @file = overwrite ? File.new(@filename, "w+") : File.new(@filename, "a+")
+
+    @file << "#{tableName}:\n"
+    for i in min...max
+      @file << "  record_#{i}:\n"
+      record.each do |fieldName, fieldValue|
+        fieldValue = fieldValue.gsub('$', i.to_s)
+        @file << "    #{fieldName}: '#{fieldValue}'\n"
+      end
+    end
+
+    @file.close if(@file)
+
+  end
+  
+  def addRecord(record, i)
+    @file = File.new(@filename, "a+")
+    @file << "  record_#{i}:\n"
+    record.each do |fieldName, fieldValue|
+      fieldValue = fieldValue.gsub('$', i.to_s)
+      @file << "    #{fieldName}: '#{fieldValue}'\n"
+    end
+    @file.close if(@file)
+  end
+
+
+  def example(count = 10)
+  
+    record = {id: '#default', name: 'name-$', name_d: 'name_d_$',  d: 'd_$'}
+    self.recordGenerator("d_tables", record, 1, count, true)
+    record = {id: '#default', name: 'name-$', name_a: 'name_a_$',  a: 'a_$'}
+    self.recordGenerator("a_tables", record, 1, count)
+    record = {id: '#default', name: 'name-$', name_b: 'name_b-$', b: 'b-$', d_tables_id: '#$ % 5 + 1', a_tables_id: '$'}
+    self.recordGenerator("b_tables", record, 1, count)
+    record = {id: '#default', name: 'name-$', name_c: 'name_c-$', c: 'c-$', b_tables_id: '$'}
+    self.recordGenerator("c_tables", record, 1, count)
+    self.recordGenerator("name_table", {name: 'name-$'}, 1, count)
+    self.recordGenerator("surname_table", {surname: 'surname-$'}, 1, count)
+    self.recordGenerator("name_table_surname_table_join", {name_table_id: '#$', surname_table_id: '#$'}, 1, count)
+    self.addRecord({name_table_id: '#1', surname_table_id: '#2'}, 10)
+    self.addRecord({name_table_id: '#1', surname_table_id: '#3'}, 11)
+    self.load
+  end
+
+end
+

data/lib/hdb/hdb.rb

@@ -0,0 +1,357 @@
+class Hash
+
+  def join(separator)
+
+    arr = []
+    self.each do |key, value|
+      arr << "\"#{key}\" = #{value}"
+    end
+    return arr.join(separator)
+
+  end
+
+  def intersect(hash)
+
+    self.select {|k,v| hash.include?(k)}
+
+  end
+  
+  def hprint
+
+    hashView = self.dup
+    #'*ptr'
+    hashView.each { |k, v| hashView[k] = v.object_id if v.class != String and v.class != Fixnum and v.class != NilClass and v.class != Float }
+    puts hashView
+
+  end
+
+  def to_js_format
+    result = []
+    self.each do |k, v|
+      tmp = (v.class <= String) ? "#{k}:#{v.to_js_format}" : "#{k}:#{v}"
+      result << tmp
+    end
+    return "{#{result.join(", ")}}"
+  end
+
+
+end
+
+class Array
+
+  def hjoin(separator, quoteChar = '"')
+
+    arr = []
+    self.each { |value| arr << "#{quoteChar}#{value}#{quoteChar}" }
+    return arr.join(separator)
+  end
+  
+  def to_js_format # used in HWidget::buildSignature
+    result = []
+    self.each do |value|
+      tmp = (value.class <= String) ? "#{value.to_js_format}" : value
+      result << tmp
+    end
+    return "[#{result.join(", ")}]"
+  end
+
+end
+
+class String
+
+  def hcapitalize
+
+    self.split('_').map(&:capitalize) * ''
+
+  end
+
+  def to_js_format
+    return "'#{self.gsub("'", "\\\\'")}'"
+  end
+
+  def to_b
+    return self == "true"
+  end
+
+end
+
+class HDB 
+
+  attr_reader :resultTable, :connection, :sth, :table
+
+  def initialize(host, port, dbname, user, password, timezone, connectionName = "default", connector = "Pg")
+
+    @host = host
+    @port = port
+    @dbname = dbname
+    @user = user
+    @password = password
+    @timezone = timezone
+    @connectionName = connectionName
+    
+    @connection = nil
+
+    @select = nil
+    @from = nil
+    @where = nil
+    @orderBy = nil
+    @direction = nil
+    @limit = nil
+    @offset = nil
+
+    @resultTable = nil
+    @table = nil
+
+  end
+
+  def method_missing(methodeName, *args)
+    return eval("HODB.new($1, @connectionName).find_by_#{$2}(*args)") if methodeName.to_s =~ /^find_on_(.+)_by_(.+)$/
+  end
+
+  # posso passare anche un array di campi
+  def select(select)
+    select = select.hjoin(', ') if(select.class == Array)
+    @select = select
+    return self
+  end
+  def from(from)
+    from = from.hjoin(', ') if(from.class == Array)
+    @from = from
+    return self
+  end
+  def normalizeWhereFormat(where, operator = 'AND')
+    where = self.quote(where) if where.class == Hash
+    where = where.join(" #{operator} ") if(where.class == Array || where.class == Hash)
+    return where
+  end
+  def where(where, operator = 'AND')
+    @where = self.normalizeWhereFormat(where, operator)
+    return self
+  end
+  def orderBy(orderBy)
+    orderBy = orderBy.hjoin(', ') if(orderBy.class == Array)
+    @orderBy = orderBy
+    return self
+  end
+  def direction(direction)
+    @direction = direction
+    return self
+  end
+  def limit(limit)
+    @limit = limit
+    return self
+  end
+  def offset(offset)
+    @offset = offset
+    return self
+  end
+  
+  def queryStr()
+ 
+    where = "WHERE #{@where}" if(@where)
+    orderBy  = "ORDER BY #{@orderBy}" if(@orderBy)
+    limit = "LIMIT #{@limit}" if(@limit)
+    offset = "OFFSET #{@offset}" if(@offset)
+    return "SELECT #{@select} FROM #{@from} #{where} #{orderBy} #{@direction} #{limit} #{offset}"
+
+  end
+
+
+  def openConnection()
+
+    hl << "connectionName: #{@connectionName}".red
+    hl << "host: #{@host}".red
+    hl << "port: #{@port}".red
+    hl << "db: #{@dbname}".red
+    hl << "user: #{@user}".red
+    hl << "password: #{@password}".red
+    hl << "timezone: #{@timezone}".red
+    @connection = self.connect() unless @connection
+
+  end
+
+
+  def closeConnection()
+    
+    self.disconnect() if @connection
+    @connection = nil
+  
+  end
+  
+  
+  def execute(queryStr = self.queryStr, pageSize: "all", page: 0) 
+    
+    limit = "LIMIT #{pageSize}"
+    offset = "OFFSET #{page} * #{pageSize}"
+    if(pageSize == "all")
+      limit = offset = ""
+    end
+
+    queryStr += " #{limit} #{offset}"
+    
+    t1 = Time.now
+    hl << queryStr.hight_yellow
+    result = self._execute(queryStr)
+    hl << "... msecs. #{((Time.now - t1) * 1000).round(2)}".hight_cyan
+    return result
+
+  end
+  
+  def quoteValue(value)
+      
+      return 'NULL' if value == nil
+      value = value.to_s.gsub("'", "''")
+      return (value[0] != '#') ? "'#{value}'" : value[1, value.size - 1]
+
+  end
+
+  def primitiveType?(value)
+
+    return (value.class == String or
+      value.class == Fixnum or
+      value.class == TrueClass or
+      value.class == FalseClass)
+
+  end
+
+  # quota tutti i valori tranne quelli che iniziano con #
+  # quindi se nella mia query devo richiamare una funzione basta farla precedere dal cancelletto
+  def quote(args)
+    
+    return 'NULL' if args == nil
+    return self.quoteValue(args) if self.primitiveType?(args) 
+    
+    result = Hash.new()
+
+    args.each do |key, value|
+      result[key] = self.quoteValue(args[key])
+    end
+    return result
+
+  end
+
+  alias_method :q, :quote
+
+  def toClassName(tableName)
+    return tableName.hcapitalize()
+  end
+
+  def insertValues(args) 
+
+    return "(id) values(default)" unless(args)
+    args = self.quote(args)
+    return "(#{args.keys.hjoin(', ')}) values(#{args.values.join(', ')})"
+
+  end
+
+  def insert(tableName, values)
+
+    return self.execute("INSERT INTO \"#{tableName}\" #{self.insertValues(values)} RETURNING id").data(0,"id") 
+
+  end
+
+  def updateValues(args) 
+
+    return "" unless(args)
+    args = self.quote(args)
+    result = []
+    args.each { |key, value| result << "\"#{key}\" = #{value}" }  
+    return result.join(', ')
+
+  end
+  
+  def update(tableName, values, where = "TRUE", operator = "AND")
+
+    where = where.join(" #{operator} ") if(where.class == Array || where.class == Hash)
+    self.execute("UPDATE \"#{tableName}\" SET #{self.updateValues(values)} WHERE #{where}") 
+    return self.rowsAffected()
+
+  end
+  
+  def delete(tableName, where = "TRUE", operator = "AND")
+    
+    where = self.quote(where) if where.class == Hash
+    where = where.join(" #{operator} ") if(where.class == Array || where.class == Hash)
+    self.execute("DELETE FROM \"#{tableName}\" WHERE #{where}") 
+    return self.rowsAffected() # rows affected
+
+  end
+  
+  def rowCount()
+
+    return self.rowsAffected()
+
+  end
+
+  def columnCount()
+
+    return self.fieldNameList.length
+
+  end
+
+  def data(row, idOrFieldName)
+
+    return (idOrFieldName.class == Fixnum) ? @table[row][@table[row].keys[idOrFieldName]] : @table[row][idOrFieldName.to_s]
+
+  end
+
+  def show()
+  
+    @table.each do |row|
+      p row
+    end
+
+  end
+
+  def self.newHDB(connectionName = "default")
+
+    params = hc.value(connectionName)
+    
+    host   = params["host"]
+    port   = params["port"]
+    dbname = params["dbname"]
+    user   = params["user"]
+    password = params["password"]
+    timezone = params["timezone"]
+    connector = params["connector"]
+
+    connector = connector.split('-') 
+
+    if (connector[0] == "hdbi")
+      hdb = HDBI.new(host, port, dbname, user, password, timezone, connectionName, connector[1])
+    elsif (connector[0] == "hpgsql")
+      hdb = HPgSql.new(host, port, dbname, user, password, timezone, connectionName)
+    elsif (connector[0] == "hmysql")
+      hdb = HMySql.new(host, port, dbname, user, password, timezone, connectionName)
+    elsif (connector[0] == "hmysql2")
+      hdb = HMySql2.new(host, port, dbname, user, password, timezone, connectionName)
+    end
+
+    hdb.openConnection()
+    HSharedData.instance().setValue(hdb, "hdb-#{connectionName}")
+    return hdb
+
+  end
+
+  def self.HDB(connectionName = "default")
+
+    hdb = HSharedData.instance().value("hdb-#{connectionName}")
+    return (hdb) ? hdb : self.newHDB(connectionName) 
+
+  end
+
+  def self.destroy(connectionName = "default")
+    
+    self.HDB(connectionName).closeConnection()
+    HSharedData.instance().setValue(nil, "hdb-#{connectionName}")
+
+  end
+
+end
+
+def hdb(connectionName = "default")
+
+  return HDB.HDB(connectionName)
+
+end
+