hypersonicplus 0.0.0

data/lib/hdb/hdb_test.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+require 'hdb/hdbi.rb' 
+
+class HODB
+
+  def self.test_1
+    contacts = Contacts.new
+    contacts.create({surname: 'Bonaffini',
+                     name: 'Herbert', 
+                     address: 'Herbert Strasse', 
+                     delivery_address: 'Herbert - Delivery', 
+                     invoice_address: 'Herbert - Invoice'})
+    contacts.show('hight_red', false)
+    contacts.writeAll
+    contacts.all
+    contacts.show('hight_yellow', false)
+  end
+
+  def self.test_2
+    suppliers = Suppliers.new
+    suppliers.create({surname: 'Viola', 
+                      name: 'Ugo', 
+                      address: 'Viola Strasse', 
+                      delivery_address: 'Viola - Delivery', 
+                      invoice_address: 'Viola - Invoice',
+                      company_name: 'VIOLA SPA'})
+    suppliers.show('hight_cyan', false)
+    suppliers.writeAll
+    suppliers.all
+    suppliers.show('hight_cyan', false)
+  end
+
+  def self.test_3
+
+    suppliers = Suppliers.new
+    supplier = suppliers.findBy_name_and_surname("Mario", "Rossi")
+    supplier.show
+
+  end
+
+  def self.test_4
+    foods = Foods.new
+    foods.all
+    foods.each do |record|
+      p record.name
+      p record.categories_id.name
+    end 
+  
+  end
+
+  def self.test_showCategories
+ 
+    categories = Categories.new
+    categories.all
+    categories.show
+    categories.each do |record|
+      p record.name
+      record.foods_table.show  # polimorfismo runtime
+    end 
+
+  end  
+
+  def self.oneToMany
+    
+    printers = Printers.new
+    kitchen = printers.create({name: 'KITCHEN'})
+    pizzeria = printers.create({name: 'PIZZERIA'})
+    bar = printers.create({name: 'BAR'})
+    
+    categories = Categories.new
+    pizze = categories.create({name: 'PIZZE BABY'}).foods_table
+    primi = categories.create({name: 'PRIMI BABY'})
+    beverage = categories.create({name: 'BEVERAGE'}).foods_table
+    
+    pizze.create({name: 'Margherita Baby', description: 'Pomodoro, Mozzarella, Basilico', price: 10, printers_id: pizzeria})
+    pizze.create({name: 'Marinara Baby', description: 'Pomodoro, Aglio, Olio', price: 10, printers_id: pizzeria})
+    pizze.create({name: 'Capricciosa Baby', description: 'Pomodoro, Mozzarella, Funghi, Olive, Uovo, Piselli, Wurstell', price: 10, printers_id: pizzeria})
+    pizze.create({name: 'Capricciosa Baby', description: 'Pomodoro, Mozzarella, Funghi, Olive, Uovo, Piselli, Wurstell', price: 10, printers_id: pizzeria})
+    pizze.create({name: 'Napoli Baby', description: 'Pomodoro, Mozzarella, Acciughe', price: 10, printers_id: pizzeria})
+    pizze.create({name: 'Taggiasca Baby', description: 'Pomodoro, Mozzarella, Olive', price: 10, printers_id: pizzeria})
+
+    primi.foods_table.create({name: 'Tagliatelle ai Porcini', description: 'Fresh Mushrooms', price: 10, printers_id: kitchen})
+    
+    primi.name = "PRIMI ITALIANI"
+   
+    beverage.create({name: 'Coke', description: 'Water and Sugar', price: 2, printers_id: bar})
+    
+    categories.writeAll
+
+  end
+  
+  def self.oneToOne
+
+    margherita = Foods.new.findBy_name("Margherita Baby")
+    margherita.printers_id.show   # oneToOne
+    margherita.categories_id.show # manyToOne
+
+  end
+
+  def self.manyToMany
+    
+    models = Models.new
+    baby = models.create({name: 'Baby Format', description: 'baby format'})
+    family = models.create({name: 'Family Format', description: 'family format'})
+    
+    categories = Categories.new
+    konditorei = categories.create({name: 'KONDITOREI'}).foods_table
+    sacher = konditorei.create({name: 'Sacher Torte', description: 'schokolade und marmelade', price: 10})
+
+    sacher_modelds_join = sacher.models_join
+
+    sacher_modelds_join.create({models_id: baby})
+    sacher_modelds_join.create({models_id: family})
+
+    categories.writeAll
+
+  end
+
+  def self.manyToMany_2
+
+    sacher = Foods.new.findBy_name("Sacher Torte")
+    sacher.models_join.rightModel.show
+
+  end
+
+  def self.manyToMany_3
+
+    family = Models.new.findBy_name("Family Format")
+
+    margherita = Foods.new.findBy_name("Margherita Baby")
+    margherita_models_join = margherita.models_join
+    margherita_models_join.create({models_id: family})
+
+    # margherita.writeAll non funzionerebbe perche' non proviene da una create
+    # la writeAll deve quindi essere eseguita dalla create radice in questo caso margherita_models_join
+    margherita_models_join.writeAll 
+
+  end
+
+  def self.test_save
+
+    pizze = Categories.new.findBy_name("PIZZE").foods_table
+    pizze.create({name: 'Diavola', description: 'Pomodoro, Mozzarella, Salamino e Peperoncino', price: 10})
+    pizze.each do |pizza|
+      pizza.price = 1 #Random.rand(10) 
+      pizza.printers_id = 1
+    end
+    #pizze.show
+    pizze.writeAll
+    pizze.saveAll
+
+  end
+  
+  def self.test_save2
+
+    capricciosa = Foods.new.findBy_name("Capricciosa")
+    capricciosa.printers_id.name = "pizzeria"
+    #capricciosa.show
+    capricciosa.saveAll
+   
+
+    puts "§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§".red
+    pizze = Categories.new.findBy_name("PIZZE")
+    pizze.foods_table.each do |pizza|
+      pizza.printers_id.name = "pippo"
+    end
+    #pizze.saveAll
+    pizze.ok
+
+
+  end
+
+  def self.test_delete
+
+    pizze = Categories.new.findBy_name("PIZZE").foods_table
+    
+    rustica = pizze.create({name: 'Rustica', description: 'Pomodoro, Mozzarella, Olive', price: 10})
+    biancaneve = pizze.create({name: 'Biancaneve', description: 'Aglio, Olio', price: 10})
+    pizze.show
+    capricciosa = Foods.new.findBy_name("Capricciosa")
+    pizze.remove(rustica)
+    pizze.remove(capricciosa)
+    pizze.writeAll
+
+  end
+
+  # Ci sono diversi modi per creare dei campi virtuali
+  # Il primo e' quello di creare una funzione all'interno nel modello es. per creare il campo amount:
+  #
+  # self.amount_virtual = HField.magic()
+  #
+  # def amount
+  #  return price.to_i * 2
+  # end
+  # 
+  # In realta' se togliamo l'istruzione magic funziona lo stesso ma non si capisce che amount e' un campo del modello
+  #
+  # Il secondo e' quello di creare il campo fuori dal modello in modo da avere piu' versatilita'
+  # In tal modo posso aggiungere i campi runtime
+  # 
+  # - products = Products.new
+  # - products.amount = HField.virtual(:amount, self) # dove amount e' la funzione e self e' l'oggetto contenente la funzione
+  #
+  # Il terzo e' quello di passare direttamente un blocco es.
+  #
+  # - products.amount = HField.virtual { |this| this.price.to_i } 
+
+  def self.amount(this)
+    return this.quantity * this.price.to_i 
+  end
+ 
+  def self.virtualFields
+
+    products = Products.new
+    products.quantity = HField.virtual { |this| this.categories_id.id.to_i }
+    products.amount = HField.virtual(:amount, HODB) # Secondo metodo ma passando il nome della classe essendo statica
+    #products.amount = HField.virtual { |this| this.quantity * this.price.to_i } # Terzo metodo
+    products.all
+    products.show("red", [:id, :quantity, :price, :amount, :score, :random])
+  
+  end
+
+  def self.test
+    
+    #HDBGenerator.new(true)
+    #self.test_save2
+    #self.virtualFields 
+    #return
+    HDBGenerator.new(true)
+    self.test_1
+    self.test_2
+    self.test_3
+    self.test_4
+    self.oneToMany
+    self.oneToOne
+    self.manyToMany
+    self.manyToMany_2
+    self.manyToMany_3
+    self.test_showCategories
+    self.test_save
+    self.test_save2
+    self.virtualFields 
+    #self.test_delete
+
+  end
+
+
+end

data/lib/hdb/hdbgenerator.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+require 'hdb/hdb'
+
+class HDBGenerator 
+
+  def newOdb(modelName)
+    className = modelName.hcapitalize
+    return eval("#{className}.new")
+  end
+
+  def initialize(dropTables = false, connectionName = "default")
+    self.initModule("quickmanager", dropTables, connectionName)
+    return
+    HDir.new("#{Dir.pwd}/app/modules/*").onlyDirectories().each do |moduleName|
+      self.initModule(moduleName, dropTables, connectionName)
+    end
+  end
+
+
+  def initModule(moduleName, dropTables = false, connectionName = "default")
+    @moduleName = moduleName
+    @connectionName = connectionName
+    @dropTables = dropTables
+
+    databases = self.databases()
+    @dbTables = self.tables()
+    
+    @htables = {} # hypersonic tables
+    for filename in Dir.glob("#{Dir.pwd}/app/modules/#{@moduleName}/*/*.rb") do
+      modelName = File.basename(filename).chomp('.rb')
+      @htables[modelName] = {}
+      self.createScaffoldTable(modelName)
+    end
+
+    @htables.each do |modelName, emptyHash|
+      oodb = self.newOdb(modelName)
+      emptyHash[:oodb] = oodb if oodb.generate
+    end
+
+    @htables.each { |modelName, oodb| self.dropTable(modelName) }
+
+    @dbTables = self.tables()
+    @htables.each  { |modelName, oodb| self.createScaffoldTable(modelName) }
+    @htables.each do |modelName, oodb|
+      fields = self.fields(modelName)
+      hfields = oodb[:oodb].hfields(false)
+  
+      fieldsToDrop = fields - hfields.keys - oodb[:oodb].systemFields().keys()
+      self.dropFields(modelName, fieldsToDrop)
+
+      self.before(modelName)
+      hfields.each do |fieldName, fieldAttrs|
+        hl << "#{modelName}.#{fieldName} #{fieldAttrs}"
+
+        next if fields.include?(fieldName)
+        next if (fieldAttrs[:type] == "oneToMany")
+        if (fieldAttrs[:type] == "manyToMany")
+          self.createTableManyToMany(modelName, fieldAttrs)
+          next
+        end
+        
+        type = self.toType(fieldAttrs[:type])
+        self.addField(modelName, 
+                      fieldName, 
+                      type, 
+                      fieldAttrs[:constraint],
+                      fieldAttrs[:default], 
+                      fieldAttrs[:modelNameReference],
+                      fieldAttrs[:onDelete],
+                      fieldAttrs[:onUpdate])
+      end
+      self.after(modelName)
+    end
+    
+    @htables.each do |modelName, oodb| 
+      self.dataLoader(modelName) if oodb[:generated]
+    end
+
+  end
+
+  def createScaffoldTable(modelName)
+    unless @dbTables.include?(modelName)
+      self.createTable(modelName)
+      self.addSystemFields(modelName)  
+      @htables[modelName][:generated] = true
+    end
+  end
+
+  def createTableManyToMany(modelName, fieldAttrs)
+    p fieldAttrs
+    type = self.toType(fieldAttrs[:type])
+    _modelName = fieldAttrs[:joinTable]
+    return if !@dropTables and @dbTables.include?(_modelName)
+    self.dropTable(_modelName) 
+    self.createTable(_modelName) 
+    self.addSystemFields(_modelName)  
+    self.addField(_modelName, fieldAttrs[:referenceFieldName], type, 
+                  fieldAttrs[:constraint], fieldAttrs[:default], modelName)
+    self.addField(_modelName, fieldAttrs[:referenceFieldName2], type, 
+                  fieldAttrs[:constraint], fieldAttrs[:default], fieldAttrs[:modelNameReference])
+  end
+
+  def dropTable(modelName)
+    return unless @dbTables.include?(modelName)
+    return unless @dropTables
+    hdb(@connectionName).execute("DROP TABLE #{modelName} CASCADE") 
+    @dbTables.delete(modelName)
+  end
+
+  def createTable(modelName)
+    return if @dbTables.include?(modelName)
+    hdb(@connectionName).execute("CREATE TABLE #{modelName} ()") 
+    @dbTables << modelName
+  end
+
+
+  def addSystemFields(modelName)
+    self.addField(modelName, :id, 'SERIAL', 'PRIMARY KEY')
+  end
+  
+  def before(modelName)
+  end
+  
+  def after(modelName)
+  end
+
+  def disableTrigger(modelName)
+    @htables[modelName][:oodb].allParents().each do |parent|
+      hdb(@connectionName).execute("ALTER TABLE #{parent.modelName} DISABLE TRIGGER ALL") 
+    end
+  end
+
+  def enableTrigger(modelName)
+    @htables[modelName][:oodb].allParents().each do |parent|
+      hdb(@connectionName).execute("ALTER TABLE #{parent.modelName} ENABLE TRIGGER ALL")
+    end 
+  end
+
+  def dataLoader(modelName)
+
+    self.disableTrigger(modelName)
+    filename = "modules/#{@moduleName}/models/#{modelName}/default_data.yml"  
+    HDataLoader.new(filename, @connectionName).load()
+    self.enableTrigger(modelName)
+  
+  end
+
+  def dropFields(modelName, fields)
+
+    fields.each do |field|
+      self.dropField(modelName, field)
+    end
+
+  end
+
+  def dropField(modelName, fieldName)
+    hdb(@connectionName).execute("ALTER TABLE #{modelName} DROP COLUMN #{fieldName}") 
+  end
+
+  def addField(modelName, fieldName, type, constraint = nil, default = nil, reference = nil, onDelete = nil, onUpdate = nil)
+    onDelete = " ON DELETE #{onDelete}" if onDelete
+    onUpdate = " ON UPDATE #{onUpdate}" if onUpdate
+    reference = " REFERENCES #{reference}(id)" if reference
+    constraint = " #{constraint}" if constraint != nil
+    default = " DEFAULT #{hdb.q(default)}" if default != nil # default could be false and so is correct default != nil
+    hdb(@connectionName).execute("ALTER TABLE #{modelName} ADD COLUMN #{fieldName} #{type}#{constraint}#{reference}#{onDelete}#{onUpdate}#{default}") if type 
+  end
+
+  def toType(type)
+
+    toPgTypes = {
+      boolean: 'bool',
+      integer: 'int4',
+      float: 'real',
+      text: 'text',
+      html: 'text',
+      date: 'date',
+      datetime: 'timestamp',
+      binary: 'bytea',
+      oneToOne: 'int4',
+      manyToOne: 'int4',
+      oneToMany: 'int4',
+      manyToMany: 'int4',
+      serialized: 'text',
+      virtual: nil
+    }
+    return toPgTypes.include?(type.to_sym) ? toPgTypes[type.to_sym] : type
+
+  end
+
+
+  def databases
+    result = hdb(@connectionName).select(:datname).from(:pg_database).where({datistemplate: 'false'}).execute
+    return result.table.column(:datname)
+  end
+
+  def tables
+    result = hdb(@connectionName).select(:tablename).from(:pg_tables).where(["schemaname != 'pg_catalog'", "schemaname != 'information_schema'"]).execute
+    return result.table.column(:tablename)
+  end
+
+  # column_name, data_type, column_default, ordinal_position
+  def fields(modelName, fieldName = "column_name")
+    result = hdb(@connectionName).select(fieldName).from('information_schema.columns').where({table_name: modelName}).execute
+    return result.table if fieldName == "*"
+    return result.table.column(fieldName)
+  end
+
+end
+
+