hypersonicplus 0.0.0

data/lib/hdb/hmysql2.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'mysql2'
+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 HMySql2 < HDB
+  
+  def initialize(host, port, dbname, user, password, timezone)
+
+    super(host, port, dbname, user, password, timezone, "hmysql2")
+    @result = nil
+
+  end
+
+  def connect()
+
+    @connection = Mysql2::Client.new(host: @host, username: @user, password: @password, database: @dbname, port: @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()
+    @result.each_with_index do |row, i|  
+      row.each do |fieldName, fieldValue|
+        @resultTable.setDataByFieldName(i, fieldName, fieldValue.to_s)
+      end
+    end
+
+    return self
+
+  end
+  
+  def fieldNameList()
+
+    fieldList = HList.new()
+    
+    @result.fields.each { |fieldName| fieldList << fieldName }
+    
+    return fieldList
+
+  end
+ 
+  def rowsAffected
+    return @connection.affected_rows()
+  end
+
+  def insert(tableName, values)
+
+    self.execute("INSERT INTO #{tableName} #{self.insertValues(values)}")
+    return @connection.last_id
+
+  end
+
+end
+

data/lib/hdb/hodb.rb

@@ -0,0 +1,948 @@
+#!/usr/bin/env ruby
+
+require 'hdb/hfield'
+
+class Array
+ 
+  # the follow function didn't use 
+  # return a table that contains only fields
+  # table = [{a:1, b:2, c:3}, {a:4, b:5, c:6}]
+  # table.filter([:a, :c]) => [{a:1, c:3}, {a:4, c:6}]
+  def filter(fields)
+    
+    result = []
+    self.each do |row|
+      result << row.select { |key, value| fields.include?(key) }
+    end
+    return result
+
+  end
+
+
+  def sortByList(fieldName, list)
+    
+    return self unless list
+
+    hash = {}
+    self.each { |row| hash[row[fieldName]] = row }
+    list.each_with_index { |id, i| self[i] = hash[id] }
+    return self
+
+  end
+ 
+  # if list = [3,2,1,0] => it reverses the @table records 
+  def sortByPositionList(list)
+    
+    return self unless list
+
+    tableCopy = []
+    self.each_with_index { |row, i| tableCopy[i] = row }
+    list.each_with_index { |id, i| self[i] = tableCopy[list[i]] }
+    return self
+
+  end
+
+  def column(fieldName, recordKey = nil)
+   
+    result = []
+    self.each do |row|
+      data = row[fieldName.to_s]
+      data = data.value(recordKey) if data.class == HRecord and recordKey
+      result << data
+    end
+    return result
+  end
+
+
+end
+
+class HRecordPtr
+    
+  attr_reader :odb, :tableCursor, :type
+    
+  def initialize(odb, type = nil)
+    @odb = odb
+    @tableCursor = @odb.tableCursor
+    @type = type
+  end
+    
+  def method_missing(sym, *args, &block)
+
+    #puts "=======================================> #{sym.to_s}".red
+    @odb.tableCursor = @tableCursor
+    return @odb.send(sym, *args, &block)
+
+  end
+
+end
+
+
+class HODB # Object DB 
+
+  attr_reader :generate, :modelName, :parentModel, :parent, :connectionName, :hfields, :table, :source, :tmp, :toWrite, :toChange, :tableCursor, :type, :sortField
+  attr_reader :domain   # riga da cancellare
+
+  def initialize(modelName = nil, parents = [], connectionName: "default", domain: {}, generate: true)
+    p "modelName: #{modelName}, parents: #{parents}, connectionName = #{connectionName}"
+    @generate = generate # if true build the table into db
+
+    @visited = []
+
+    @toWrite = []
+    @toChange = []
+    @toDelete = []
+
+    @vid = 0 # virtual id
+
+    @tmp = {}
+    @type = nil 
+    @source = nil
+    @domain = domain # it's required for example to group the result of oneToMany relation or manyToMany
+    @modelName = modelName
+    @connectionName = connectionName
+    @parents = [] # pairs of type {ptr: 0x..., referenceFieldName: 'modelname_id'}
+    @hfields = {} # hypersonic fields
+    @tableFields = nil # fields of table
+    @modelFields = nil # fields of table + fields of all parents
+    @table = []
+    @tableCursor = nil 
+    @allParents = nil
+
+    self.setParents(parents)
+    self.setSystemFields()
+
+    self.init()
+
+  end
+
+  def recordPtr(type = nil)
+    return HRecordPtr.new(self, type)
+  end
+
+  def newHODB(modelName, type: nil, domain: {})
+    _modelName = modelName.to_s.hcapitalize
+    #puts "newHODB: #{modelName}"
+    p "#{_modelName}.new(connectionName: @connectionName, domain: domain)"
+    odb = (Object.const_defined?(_modelName)) ? eval("#{_modelName}.new(connectionName: @connectionName, domain: domain)") : HODB.new(modelName, connectionName: @connectionName, domain: domain)
+    odb.source = self
+    odb.type = type if type
+    return odb
+
+  end
+ 
+  def self.newOdb(modelName, connectionName = "default", domain: {})
+    className = modelName.hcapitalize
+    return eval("#{className}.new(connectionName: connectionName, domain: domain)")
+  end
+
+  def ptrOfRecord(fieldName, fieldValue)
+    
+    return fieldValue.tableCursor if fieldValue.class == HRecordPtr # Se si tratta gia' di un ptr a un record lo restituisce
+    @table.each do |record|
+      return record if record[fieldName.to_s] == fieldValue
+    end  
+    return nil
+
+  end
+
+  def allParents()
+    return @allParents if @allParents
+    @allParents = [self]
+    @parents.each { |parent| @allParents += parent[:ptr].allParents() }
+    return @allParents 
+  end
+  
+  def tableFields # return only the fields of table
+    self.findBy(:false, []) unless @tableFields # poputate @tableFields
+    return @tableFields
+  end
+
+  def modelFields # return all fields 
+    return @modelFields if @modelFields
+    @modelFields = Marshal.load(Marshal.dump(self.tableFields()))
+    @parents.each { |parent| @modelFields.merge!(parent[:ptr].modelFields()) }
+    return @modelFields
+  end
+
+  def systemFields(inheritance = false) 
+    return self.hfields(inheritance).select { |fieldName, field| field[:system] }
+  end
+
+  def hfields(inheritance = true)
+    return @hfields unless inheritance
+    return @allHfields if @allHfields
+    @allHfields = {}
+    @hfields.each { |fieldName, fieldValue| @allHfields[fieldName] = fieldValue }
+    @parents.each { |parent| @allHfields.merge!( parent[:ptr].hfields(inheritance) ) }
+    return @allHfields
+  end
+  
+
+  # false: return only fields of table
+  # true:  return the fields of table + parents fields
+  # :false: return only hfields of table
+  # :true: return only hfields of table + parents hfields
+  def fields(inheritance = false)
+
+    return inheritance if inheritance.class == Array
+
+    case inheritance
+    when true 
+      return self.modelFields() 
+    when false 
+      return self.tableFields()
+    when :true
+      return self.hfields(:true)
+    when :false
+      return self.hfields(:false)
+    end
+
+  end
+
+  def nodeOfField(fieldName)
+    result = self.fields().include?(fieldName) ? [self] : []
+    @parents.each { |parent| result += parent[:ptr].nodeOfField(fieldName) }
+    return @nodes = result
+  end
+  
+  def valueOfField(fieldName)
+    nodes = self.nodeOfField(fieldName)
+    return (nodes.any?) ? nodes[0].tableCursor[fieldName] : nil
+  end
+  
+  def setValueOfField(fieldName, fieldValue)
+    nodes = self.nodeOfField(fieldName)
+    nodes.each { |node| node.tableCursor[fieldName] = fieldValue }
+  end
+  
+  def setParents(parents = [])
+    parents.each do |modelName|
+      referenceFieldName = "#{modelName}_id"
+      parent = {modelName: modelName, referenceFieldName: referenceFieldName}
+      self.addField(referenceFieldName, HField.oneToOne(modelName))  
+      #parent[:ptr] = self.newHODB(modelName, domain: @domain)
+      parent[:ptr] = self.newHODB(modelName)
+      @parents << parent
+    end
+
+  end 
+  
+  def setSystemFields()
+    self.id = HField.primaryKey
+    self.created_date = HField.dateTime(default: '#CURRENT_TIMESTAMP', system: true)
+    self.updated_date = HField.dateTime(default: '#CURRENT_TIMESTAMP', system: true)
+    self.ordering = HField.integer(system: true)
+  end
+
+  def addField(fieldName, args)
+    
+    field = HField.autoComplete(@modelName, fieldName, args) # For the magic field
+    @hfields[fieldName] = field
+    hl << "addField: #{fieldName} #{field}"
+  
+  end
+
+  def oneToOne(modelName, referenceFieldName)
+ 
+    return self.manyToOne(modelName, referenceFieldName, 'oneToOne')
+
+  end
+  
+  def manyToOne(modelName, referenceFieldName, type = 'manyToOne')
+ 
+    return @tableCursor[modelName] if @tableCursor[modelName]
+    id = self.valueOfField(referenceFieldName)
+    @tableCursor[modelName] = odb = self.newHODB(modelName, type: type)
+    @visited.addIfNotPresent(odb)
+    puts "modelName: #{referenceFieldName}".red
+    @tableCursor.hprint
+    unless id 
+      self.setValueOfField(referenceFieldName, odb.recordPtr(type))
+      return odb
+    end
+    @toChange << @tableCursor unless @toChange.include?(@tableCursor)
+    return odb.findBy_id(id)
+ 
+  end
+
+  def oneToMany(fieldName, modelName, referenceFieldName)
+    
+    return @tableCursor[fieldName] if @tableCursor[fieldName]
+    if(self.id[0] != "#")
+      domain = {"#{referenceFieldName}": self.id}
+      odb = self.newHODB(modelName, type: 'oneToMany', domain: domain).findBy()
+      return  @visited.addIfNotPresent(odb)
+    end
+    domain = {"#{referenceFieldName}": nil}
+    odb = self.newHODB(modelName, type: 'oneToMany', domain: domain)
+    @tableCursor[fieldName] = odb
+    @visited.addIfNotPresent(odb)
+    return odb
+  end
+
+  def manyToMany(modelName, joinTable, referenceFieldName, referenceFieldName2)
+  
+    odb = self.oneToMany(joinTable, joinTable, referenceFieldName)
+    odb.type = 'manyToMany'
+    odb.tmp[:referenceFieldName] = referenceFieldName2
+    odb.tmp[:rightModelName] = modelName
+    return odb
+  
+  end
+
+  # a_table <--> manyToMany <--> b_table
+  # To access to b_table from a_table -> a_table.a_table_b_table_join.rightModel
+  # Moreover on right model is unsense call the create function
+  def rightModel
+    
+    rightModelName = @tmp[:rightModelName]
+    return @tableCursor[rightModelName] if @tableCursor[rightModelName]
+
+    ids = @table.column(@tmp[:referenceFieldName]) 
+    where = "id IN (#{ids.join(',')})"
+    odb = self.newHODB(rightModelName, type: 'rightTable').findBy(where) if (@type == 'manyToMany')
+    @visited.addIfNotPresent(odb)
+    return @tableCursor[rightModelName] = odb
+
+  end
+  
+  def virtualField(obj, functionName, &block)
+
+    return block.call(self) if block
+    #hl <<  "obj.#{functionName.to_s}(self)"
+    return eval("obj.#{functionName.to_s}(self)") if obj and functionName
+
+  end
+
+  def inspection(str)
+    puts "=============> #{str}"
+    return false
+  end
+
+  def fieldProperty(fieldName, property)
+    
+    return nil unless fieldName
+    hfield = self.hfields()[fieldName.to_s] || self.hfields()[fieldName.to_sym]
+    return hfield[property.to_s] || hfield[property.to_sym] if hfield
+    return nil
+
+  end
+
+
+  #   [[:a, :b, :c], [1, 2, 3]].transpose
+  #   => [[:a, 1], [:b, 2], [:c, 3]]    
+  def method_missing(sym, *args, &block)
+    if sym =~ /^(\w+)=$/
+      if args[0].class == HField
+        self.addField($1.to_s, args[0])
+      elsif self.nodeOfField($1.to_s).any?
+        @nodes.each { |node| node.tableCursor[$1.to_s] = args[0] if node.tableCursor }
+        @toChange << @tableCursor if (!@toChange.include?(@tableCursor) and @tableCursor) 
+      elsif instance_variable_defined?("@#{$1.to_s}") # is required to use attr_reader to setting
+        instance_variable_set("@#{$1}", args[0])
+      else
+        hl.<<("hodb::method_missing: #{$1.to_s} not found", "ERROR")
+      end
+      return
+    elsif sym.to_s =~ /^findBy_(.+)$/
+      attrs = $1.split('_and_')
+      attrs_with_args = [attrs, args].transpose
+      where = Hash[attrs_with_args]
+      return self.findBy(where) 
+    elsif @hfields[sym.to_s] and @hfields[sym.to_s][:modelNameReference]
+      modelName = @hfields[sym.to_s][:modelNameReference]
+      type = self.fieldProperty(sym, :type)
+      return self.oneToOne(modelName, sym.to_s) if (type == 'oneToOne')
+      return self.manyToOne(modelName, sym.to_s) if (type == 'manyToOne')
+      referenceFieldName = @hfields[sym.to_s][:referenceFieldName]
+      return self.oneToMany(sym.to_s, modelName, referenceFieldName) if (type == 'oneToMany')
+      joinTable = @hfields[sym.to_s][:joinTable]
+      referenceFieldName2 = @hfields[sym.to_s][:referenceFieldName2]
+      return self.manyToMany(modelName, joinTable, referenceFieldName, referenceFieldName2) if (type == 'manyToMany')
+    elsif @hfields[sym.to_s] and @hfields[sym.to_s][:type] == 'virtual' 
+      return self.virtualField(@hfields[sym.to_s][:object] || self, @hfields[sym.to_s][:functionName], &@hfields[sym.to_s][:block])
+    elsif sym =~ /^(\w+)_id$/
+      return self.manyToOne($1.to_s, sym.to_s)
+    elsif sym =~ /^(\w+)_table$/
+      return self.oneToMany(sym.to_s, $1.to_s, "#{@modelName}_id")
+    elsif sym =~ /^(\w+)_join$/
+      return self.manyToMany($1.to_s, "#{@modelName}_#{$1.to_s}_join", "#{@modelName}_id", "#{$1.to_s}_id")
+    elsif @tableCursor and @tableCursor.include?(sym.to_s)
+      return @tableCursor[sym.to_s]
+    #elsif sym =~ /^(\w+)_virtual$/
+    #  return self.virtualField($1.to_s, self, &block)
+    else 
+      @parents.each do |parent| 
+        result = parent[:ptr].method_missing(sym, *args, &block)
+        return result if result
+      end
+    end
+    hl.<<("hodb::method_missing: #{sym.to_s} not found", "ERROR")
+    return nil
+  end
+
+
+  def reset
+    @parents.each { |parent| parent[:ptr].reset }
+    @tableCursor = nil
+  end
+
+  def first
+    self.reset
+    return self.next
+  end
+  
+  def last
+    @tableCursor = @table.count > 0 ? @table[@table.count - 1] : nil
+    return self
+  end
+  
+  def setTableCursor(tableCursor = @tableCursor)
+    @tableCursor = tableCursor
+    @id = @tableCursor["id"]
+    @parents.each do |parent|
+      parentTableCursor = @tableCursor[parent[:referenceFieldName]]
+      parentTableCursor = parent[:ptr].ptrOfRecord("id", parentTableCursor)
+      parent[:ptr].setTableCursor(parentTableCursor)
+    end
+    return self
+  end
+
+  def next()
+    
+    index = @tableCursor ? @table.index(@tableCursor) + 1 : 0
+  
+    if (index < @table.count)
+      @tableCursor = @table[index]
+      self.setTableCursor 
+      return self
+    end
+    return nil
+
+  end
+  
+  def each
+            
+    self.execute unless @executed
+
+    self.reset()
+    while(self.next) do
+      yield(self)
+    end
+
+    @tableCursor = nil
+    self.init()
+
+  end
+  
+  def each_with_index
+    i = -1
+    self.each do |record|
+      yield(self, i += 1)
+    end
+  end
+
+
+  def eachField(inheritance = true)
+    self.fields(inheritance).each do |fieldName, fieldValue|
+      fieldValue = self.data(fieldName) 
+      fieldValue = eval("self.#{fieldName}") unless fieldValue # si tratta di campi virtual runtime
+      yield(fieldName, fieldValue)
+    end
+  end
+
+
+  def toFieldTable(inheritance = true)
+    
+    fieldTable = HSpreadFieldTable.new
+    fieldTable.tableName = @modelName
+
+    self.fields(inheritance).each do |fieldName, fieldValue|
+      fieldTable.addFieldName(fieldName)
+      fieldTable.setFieldCaption(fieldName, fieldName.to_s.hcapitalize)
+      fieldType = self.fieldProperty(fieldName.to_s, :type) 
+      fieldTable.setFieldType(fieldName, fieldType) if fieldType
+    end
+
+    self.each_with_index do |row, i|
+      row.eachField(inheritance) do |fieldName, fieldValue|  
+        fieldTable.setIntoRecordByFieldName(i, fieldName, fieldValue)
+      end
+    end
+
+    return fieldTable
+
+  end
+
+  def allRelations
+    result = []
+    result << hdb(@connectionName).normalizeWhereFormat(@domain) if @domain.class == String or @domain.any?
+    @parents.each do |parent|
+      result += ["#{@modelName}.#{parent[:referenceFieldName]} = #{parent[:ptr].modelName}.id"] + parent[:ptr].allRelations 
+    end
+    return result
+  end
+
+  def allModels
+    result = []
+    self.allParents().each { |parent| result << parent.modelName unless result.include?(parent.modelName) }
+    return result
+  end
+  
+  def modelNameOfField(fieldName)
+
+    fieldName = fieldName.to_s    
+    node = self.nodeOfField(fieldName)
+    return (node.any?) ? node[0].modelName : nil
+
+  end
+  
+  def modelNameAndFieldName(fieldName)
+
+    modelName = self.modelNameOfField(fieldName)
+    return (modelName) ? "#{modelName}.#{fieldName}" : fieldName
+
+  end
+  
+  def data(fieldName)
+    
+    fieldName = fieldName.to_s    
+    node = self.nodeOfField(fieldName)
+    return (node.any?) ? node[0].tableCursor[fieldName] : nil
+
+  end
+  
+
+  def normalizeWhereFormat(where)
+    
+    if where.class == Hash # findBy {'c_tables.id': 1}
+      newWhere = {} 
+      where.each { |fieldName, fieldValue| newWhere[self.modelNameAndFieldName(fieldName)] = fieldValue }
+      where = newWhere
+    end
+    
+    return hdb(@connectionName).normalizeWhereFormat(where)
+
+  end
+ 
+  def init()
+    @where = "true"
+    @orderBy = "id"
+    @pageSize = "all"
+    @page = 0
+  end
+
+  def where(where)
+    @executed = false
+    @where = where
+    return self
+  end
+  def orderBy(orderBy)
+    @executed = false
+    orderBy = orderBy.hjoin(', ') if(orderBy.class == Array)
+    @orderBy = orderBy
+    return self
+  end
+  def direction(direction)
+    @executed = false
+    @direction = direction
+    return self
+  end
+  def pageSize(pageSize)
+    @executed = false
+    @pageSize = pageSize
+    return self
+  end
+  def page(page)
+    @executed = false
+    @page = page
+    return self
+  end
+
+  def sortOffLine(fieldName = "id", sortDirection = 'desc', sortMap = [])
+    
+    # table = [{id:7, name:'valerio', surname:'bianchi'}, 
+    #          {id:8, name:'mario', surname:'rossi'},
+    #          {id:6, name:'laura', surname:'neri'}]
+    #
+    # table.sort_by { |row| row["name"] } =>
+    #          {id:6, name:'laura', surname:'neri'},
+    #          {id:8, name:'mario', surname:'rossi'},
+    #          {id:7, name:'valerio', surname:'bianchi'} 
+    # columnSorted = tableSorted.column("id") => [1, 3, 2]
+    # idColumn = @table.column("id") => [2, 3, 1]
+    # sortMap => [2, 1, 0]
+    # A this time to print the records it is enough to scan sortMap
+    # The first element to print is @table[2] => @table[1] => @table[0]
+
+    puts "========================================================".red
+    puts "=======                sortOffLine               =======".red
+    puts "========================================================".red
+    puts "currentModelName: #{@modelName}".red
+    if sortMap.empty?
+      node = self.nodeOfField(fieldName)[0]
+      return unless node
+      puts "modelName of #{fieldName}: #{node.modelName}".red
+
+      p node.hfields()
+      fieldType = node.hfields()[fieldName] ? node.hfields()[fieldName][:type] : nil
+      puts "type of #{fieldName}: #{fieldType}" 
+      tableSorted = nil
+      if fieldType == "integer"
+        tableSorted = node.table.sort_by { |row| row[fieldName].to_i }
+      elsif fieldType == "float"
+        tableSorted = node.table.sort_by { |row| row[fieldName].to_f }
+      elsif fieldType == "time"
+        tableSorted = node.table.sort_by { |row| row[fieldName].to_time }
+      elsif fieldType == "date_time"
+        tableSorted = node.table.sort_by { |row| row[fieldName].to_datetime }
+      else
+        tableSorted = node.table.sort_by { |row| row[fieldName] }
+      end
+
+      tableSorted.reverse! if sortDirection == 'asc'
+
+      columnSorted = tableSorted.column("id")
+      idColumn = node.table.column("id")
+      columnSorted.each_with_index { |value, i| sortMap[i] = idColumn.index(value) }
+      p sortMap
+    end
+      
+    @table.sortByPositionList(sortMap)
+
+    @parents.each do |parent|
+      parent[:ptr].sortOffLine(nil, sortDirection, sortMap)
+    end
+
+  end
+
+  #  findByOffLine({id: 1, name: 'margherita'})
+  def findByOffLine(where)
+
+    tableCursor = @tableCursor 
+    self.each do |record|
+      return self if where.each do |fieldName, fieldValue| 
+        #puts "#{record.valueOfField(fieldName.to_s)} -  #{fieldValue}"
+        break if record.valueOfField(fieldName.to_s) != fieldValue 
+      end
+    end
+    self.setTableCursor(tableCursor) # if not found restore the tableCursor value
+    return self
+
+  end
+
+  # example: findBy({id: 1})
+  #          findBy({'c_tables.id': 1}) - I can specify the field of the another table 
+  #          findBy({id: 1, name: 'ciao'}) -> c_tables.id = '1' AND c_tables.name = 'ciao' 
+  #          The follow statement isn't safe. You can use it, only if the values don't come from forms but they are statics
+  #          findBy(["c_tables.id > 0", "c_tables.name = 'ciao'"]) 
+  #          The follow statement is safe as the ? syntax and you can use the values from forms
+  #          findBy(["c_tables.id > 0", "c_tables.name = #{q(form_field)}"]) 
+  
+  def findBy(where = 'true', ids = nil, orderBy: nil, direction: nil, pageSize: "all", page: 0)
+  
+    return self unless where 
+    where = self.normalizeWhereFormat(where)
+        
+    model = (ids == nil) ? self.allModels.join(', ') : @modelName
+    where = (self.allRelations << where).join(' and ') if !ids and where
+   
+    hdb = hdb(@connectionName).
+      select("#{modelName}.*").
+      from(model).
+      where(where).
+      orderBy(orderBy).
+      direction(direction).
+      execute(pageSize: pageSize, page: page)
+
+    @tableFields = Hash[hdb.fieldNameList()]
+    @table = hdb.table.sortByList("id", ids)
+    @tableCursor = nil
+
+    return self if @table.count == 0
+
+    @parents.each do |parent|
+      ids = @table.column(parent[:referenceFieldName])
+      parent[:ptr].findBy("id IN (#{ids.join(',')})", ids)
+    end
+    return self.next().recordPtr('manyToOne')
+
+  end
+
+  def execute
+    # @executed serve per evitare di chiamare execute nelle istruzioni del tipo:
+    # odb.where(filter).orderBy(sortField).direction(sortDirection).pageSize(pageSize).page(page)
+    @executed = true
+    return self.findBy(@where, nil, orderBy: @orderBy, direction: @direction, pageSize: @pageSize, page: @page)
+  end 
+
+  def all
+    return self.findBy()
+  end
+
+  def defaultValue(fieldName)
+    field = @hfields[fieldName.to_s]
+    return nil unless field
+    return (field[:default]) ? field[:default] : field.defaultValue()
+  end
+
+  def defaultRecord(record)
+    defaultRecord = Marshal.load(Marshal.dump(self.fields()))
+    defaultRecord.each { |fieldName, fieldValue| defaultRecord[fieldName.to_s] = self.defaultValue(fieldName) }
+    defaultRecord["id"] = "##{@vid+=1}"
+    record.each {|fieldName,fieldValue| defaultRecord[fieldName.to_s] = fieldValue if defaultRecord.include?(fieldName.to_s)}
+    @domain.each {|fieldName,fieldValue| defaultRecord[fieldName.to_s] = fieldValue if defaultRecord.include?(fieldName.to_s)} if @domain.class == Hash
+    puts "#{defaultRecord}".red
+    return defaultRecord
+  end
+
+  def create(record = {})
+    defaultRecord = self.defaultRecord(record)
+    @parents.each { |parent| defaultRecord[parent[:referenceFieldName]] = parent[:ptr].create(record) }
+    @toWrite << defaultRecord
+    @table << defaultRecord
+    self.last
+    return self.recordPtr("parent")
+  end
+
+  def setRecord(record, tableCursor = @tableCursor)
+    @toChange << tableCursor unless @toChange.include?(tableCursor)
+    record.each do |fieldName, fieldValue| 
+      unless self.fields(true).include?(fieldName.to_s)
+        hl.<<("hodb::setRecord: #{fieldName.to_s} not found", "ERROR")
+        next
+      end
+      setValueOfField(fieldName.to_s, fieldValue) 
+    end
+  end
+
+
+  def write(values = {})
+    hl << "********************************* write(#{@type}) *********************************"
+    return self unless @toWrite.include?(@tableCursor)
+    return self unless values  
+    puts "#{values}".red
+    @tableCursor.merge!(values)
+    @tableCursor["id"] = "#default" if @tableCursor["id"][0] == "#"
+    @tableCursor.each do |fieldName, fieldValue| 
+      if fieldValue.class == HRecordPtr 
+        if fieldValue.type == "parent"
+          @tableCursor[fieldName] = fieldValue.write(values).id 
+        elsif fieldValue.type == "manyToOne" or fieldValue.type == "oneToOne"
+          @tableCursor[fieldName] = fieldValue.write().id 
+        elsif fieldValue.type == nil # questo caso non deve verificarsi
+          hl.<<("hodb::write: ", "ERROR")
+          fieldValue.tableCursor.hprint
+        end
+      end
+    end
+    # intersect rimuove ad es. i campy oneToMany e i campi inseriti dalla merge! sopra se non fanno parte del @tableCursor
+    @tableCursor["id"] = hdb(@connectionName).insert(@modelName, @tableCursor.intersect(self.fields))
+    @tableCursor.each do |fieldName, fieldValue| 
+      if fieldValue.class <= HODB and (fieldValue.type == 'oneToMany' or fieldValue.type == 'manyToMany' or fieldValue.type == 'rightTable')
+        referenceFieldName = fieldValue.domain.keys[0].to_s
+        fieldValue.writeAll({"#{referenceFieldName}" => @tableCursor["id"]})
+      end
+    end
+    @toWrite.delete(@tableCursor) 
+    return self
+  end
+
+  def writeAll(values = {})
+
+    puts "********************* writeAll ********************".pink
+
+    @toDelete.each { |record| self.delete({id: record["id"]}) }
+    @toDelete.clear
+
+    toWrite = @toWrite.dup
+    toWrite.each do |record| 
+      @tableCursor = record
+      self.write(values)
+    end
+    return self
+  end 
+
+  def save(values = {})
+    hl << "********************************* save(#{@type} - #{@modelName}) *********************************"
+    #return self unless @toChange.include?(@tableCursor)
+    puts "#{values}".red
+    @tableCursor.hprint
+    @tableCursor.merge!(values)
+    @tableCursor["id"] = "#default" if @tableCursor["id"][0] == "#"
+    self.setTableCursor(@tableCursor)
+    @tableCursor.each do |fieldName, fieldValue| 
+      if fieldValue.class <= HODB and (fieldValue.type == 'manyToOne' or fieldValue.type == 'oneToOne')
+        puts "call: #{fieldName} - #{fieldValue.domain}".red
+        @tableCursor[fieldName] = fieldValue.saveAll().id 
+      end
+    end
+    @parents.each { |parent| parent[:ptr].save(values) }
+    # intersect rimuove ad es. i campy oneToMany e i campi inseriti dalla merge! sopra se non fanno parte del @tableCursor
+    hdb(@connectionName).update(@modelName, @tableCursor.intersect(self.fields), {id: @tableCursor["id"]})
+    @tableCursor.each do |fieldName, fieldValue| 
+      if fieldValue.class <= HODB and (fieldValue.type == 'oneToMany' or fieldValue.type == 'manyToMany' or fieldValue.type == 'rightTable')
+        p "saveAll".red
+        fieldValue.saveAll()
+      end
+    end
+    @toChange.delete(@tableCursor) 
+    return self
+  end
+ 
+  def saveAll(values = {})
+    toChange = @toChange.dup
+    toChange.each do |record| 
+      @tableCursor = record
+      self.save(values)
+    end
+    return self
+  end
+
+  def delete(where = "TRUE", ids = nil)
+    
+    where = self.normalizeWhereFormat(where)
+
+    model = (ids == nil) ? self.allModels.join(', ') : @modelName
+    where = (self.allRelations << where).join(' and ') unless ids
+    
+    @tableCursor = nil
+    table = hdb(@connectionName).select("#{modelName}.*").from(model).where(where).execute.table
+    return self if table.count == 0
+
+    ids = table.column(:id)
+    hdb(@connectionName).delete(@modelName, "id IN (#{ids.join(',')})")
+
+    ids.each { |id| @table.delete(self.ptrOfRecord("id", id)) } 
+    
+    @parents.each do |parent|
+      ids = table.column(parent[:referenceFieldName])
+      parent[:ptr].delete("id IN (#{ids.join(',')})", ids)
+    end
+    return self
+
+  end
+
+
+  def _remove(record = @tableCursor)
+
+    record = record.tableCursor if record.class == HRecordPtr 
+    puts "_remove: #{record}".pink
+    puts "============================".red
+    if (record["id"][0] == "#")
+      @parents.each { |parent| record[parent[:referenceFieldName]]._remove }
+      @toWrite.delete(record)
+      @toChange.delete(record)
+    else
+      @parents.each do |parent| 
+        referenceFieldName = parent[:referenceFieldName]
+        id = record[referenceFieldName]
+        parent[:ptr].remove(id)
+      end
+      @toDelete << record   
+    end
+    @table.delete(record)
+
+  end
+
+  # virtual remove => the real removal happens with apply
+  def remove(recordId = @tableCursor["id"])
+
+    puts "remove: #{@modelName} - #{recordId}".yellow
+    self.findByOffLine({id: recordId})
+    self._remove(@tableCursor)
+
+  end
+
+
+  def apply
+    puts "************************* apply **********************".pink
+    self.writeAll
+    self.saveAll
+    @parents.each { |parent| parent[:ptr].apply }
+    @visited.each do |odb|
+      puts "####################################=> #{odb.modelName}".pink
+      odb.apply
+    end
+    @visited.clear
+  end
+
+  def columnWidth(fieldName, inheritance = true)
+    
+    return @colsWidth[fieldName] if @colsWidth.include?(fieldName)
+
+    maxLength = fieldName.length
+    self.each do |row|
+      row.eachField(inheritance) do |fieldName, fieldValue|  
+        len = fieldValue.to_s.length 
+        maxLength = len if maxLength < len and fieldValue.class != HRecordPtr and fieldValue.class > HODB
+      end
+    end
+    
+    return @colsWidth[fieldName] = maxLength
+
+  end
+
+  def showValue(fieldName, fieldValue, color = nil, separator = '|')
+    
+    fieldValue = fieldValue.object_id if fieldValue.class == HRecordPtr or fieldValue.class <= HODB
+    value = " #{fieldValue.to_s.center(self.columnWidth(fieldName))} #{separator}"
+    unless color
+      print value
+    else
+      print eval "'#{value}'.#{color}"
+    end
+  end
+
+  def showHeader(color, inheritance = true)
+
+    puts
+    print eval "' >> #{@modelName.to_s} <<'.#{color}"
+    puts
+    self.fields(inheritance).each do |fieldName, fieldValue|
+      self.showValue(fieldName, "-" * self.columnWidth(fieldName, inheritance), color, '+' )
+    end
+    puts
+    self.fields(inheritance).each do |fieldName, fieldValue|
+      self.showValue(fieldName, fieldName, color, '|')
+    end
+    puts
+    self.fields(inheritance).each do |fieldName, fieldValue|
+      self.showValue(fieldName, "-" * self.columnWidth(fieldName, inheritance), color, '+' )
+    end
+    puts
+  end
+  
+  def show(color = 'hight_cyan', inheritance = true)
+    @colsWidth = {}
+    @parents.each do |parent|
+      parent[:ptr].show(color, inheritance) unless (inheritance)
+    end
+    self.showHeader(color, inheritance) 
+    self.each do |row|
+      row.eachField(inheritance) do |fieldName, fieldValue|  
+        self.showValue(fieldName, fieldValue, 'white')
+      end
+      puts 
+    end
+  end
+
+  def self.test1
+    a = HODB.new({a: 1, b: 2, c: 3})
+    a.a = 0
+    p a.a
+    p a.b
+    a.d = 40 # make a variable automatically
+    p a.d
+  end
+
+  def self.test2
+    odb = HODB.new
+    odb.name = HField.text(caption: 'Name', mandatory: true, readonly: false)
+    odb.name = "hypersonic"
+    p odb.hfields(:name), odb.name
+  end
+
+end  
+
+#HODB.test2