Development

class CreateComics < ActiveRecord::Migration
  def self.up
    create_table :comics do |t|
      t.string :name
      t.string :description
      t.float :price
      t.timestamps
    end
  end

  def self.down
    drop_table :comics
  end
end

require 'app/configuration'
module RubyAMF
  module Configuration
    ClassMappings.ignore_fields   = ['created_at','created_on','updated_at','updated_on']
    ClassMappings.translate_case  = true
    ClassMappings.assume_types    = false
    ParameterMappings.scaffolding = false

    
    ClassMappings.register(:actionscript => 'Comic', 
  :ruby => 'Comic', 
  :type => 'active_record', 
  :attributes => ["id","name","description","price", "created_at", "updated_at"])

    ClassMappings.force_active_record_ids = true
    ClassMappings.use_ruby_date_time = false
    ClassMappings.use_array_collection = false
    ClassMappings.check_for_associations = false
    ParameterMappings.always_add_to_params = true
   end
end

package vo
{

 [RemoteClass(alias="Comic")]
 [Bindable]
 public class Comic
 {
     public var id:int;
  public var name:String;     
  public var description:String;     
  public var price:Number;
  public var createdAt:Date;
  public var updatedAt:Date;     
  public function Comic()
  {
  }


 }
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
  creationComplete="loadAll2();">

<mx:Script>
 <![CDATA[
  import mx.rpc.AsyncToken;
  import mx.rpc.events.FaultEvent;
  import mx.rpc.events.ResultEvent;
  import mx.controls.Alert;
  import vo.Comic;

  [Bindable]
  private var comics:Array = new Array();
 
  private function loadAll2():void {
            var token:AsyncToken = AsyncToken(comicService.find_all());
            token.kind = "fill";
  }

  private function save2():void {
   var comic:Comic = new Comic();
   comic.id          = dg2.selectedItem.id;
   comic.name        = Name2.text;
   comic.description = Description2.text;
            var token:AsyncToken = AsyncToken(comicService.save(comic));
            token.kind = "save";
   
  }

  private function create2():void {
   var comic:Comic = new Comic();
   comic.name        = Name2.text;
   comic.description = Description2.text;
            var token:AsyncToken = AsyncToken(comicService.save(comic));
            token.kind = "create";
  }
 
  
  private function destroy2():void {
            var token:AsyncToken = AsyncToken(comicService.destroy(dg2.selectedItem.id));
            token.kind = "delete";
  }

  private function faultHandler(event:FaultEvent):void {
   Alert.show(event.fault.faultString + " : " + event.fault.faultCode + " : " + event.fault.faultDetail , "Error in LoginCommand");
  }

  private function resultHandler2(event:ResultEvent):void {
    if ( event.token.kind == "fill" ) { 
      comics = event.result as Array;
    } else {
     loadAll2();
    }
  }

  
  
 ]]>
</mx:Script>
 <mx:RemoteObject id="comicService" destination="rubyamf"
   endpoint="http://localhost:3000/rubyamf_gateway/"
   source="ComicsController"
   showBusyCursor="true" 
   result="resultHandler2(event)"
   fault="faultHandler(event)" />

 <mx:ApplicationControlBar>
  <mx:Button label="Create" click="create2()"/>
  <mx:Button label="Update" click="save2()"/>
  <mx:Button label="Delete"  click="destroy2()"/>
  <mx:Button label="Refresh" click="loadAll2()"/>
 </mx:ApplicationControlBar>
 
 <mx:DataGrid id="dg2" dataProvider="{comics}">
   <mx:columns>
     <mx:DataGridColumn dataField="id"            headerText="Key"/>
     <mx:DataGridColumn dataField="name"          headerText="Name"/>
     <mx:DataGridColumn dataField="description"   headerText="Description"/>
   </mx:columns>
 </mx:DataGrid>
 <mx:Form >
   <mx:FormItem label="Name">
  <mx:TextInput   id="Name2"  text="{dg2.selectedItem.name}" />
   </mx:FormItem>
   <mx:FormItem label="Description">
  <mx:TextInput id="Description2" text="{dg2.selectedItem.description}"/>
   </mx:FormItem>
 </mx:Form>
</mx:Application>

• Downloading the full version from OTN.


• Download the patchset 7313609 from METALINK.

Jacob Madsen from Brandsoft in Denmark has written a community white paper on how his company has integrated MapViewer with Oracle Forms. Having seen a demo from Jacob, its pretty amazing stuff. Highlighing a region on a map queries data into you Forms block from that map area.

You can get a copy of the paper here.

With Oracle Forms we are moving towards certification with the Sun plug-in. We already certify 1.4, 1.5 and 1.6 with various versions of Oracle Forms. If you want to know how to set up Oracle Forms to run with the Java Plug-in then you can read this article.

Some database applications require you to perform a series of actions where you know only that some actions must be performed before others. Before you can perform the actions, you must work out a safe sequence that takes into account all of the dependencies. This week in The Database Programmer we will see an algorithm for doing this.

There are many examples where a programmer must work out dependencies before doing something.

A manufacturing package may track many steps in the manufacture of an item. Some steps cannot be performed until others are complete. A simple system would require the end-user to work out the entire process, but a better system would let the user enter only the dependencies: which processes require others to be complete. In this kind of system the computer can be used to schedule manufacturing tasks.

All popular Linux distributions have a package installation system in which each package lists its required dependencies. If you want to install a large number of packages in one shot, producing a tangled bunch of related dependencies, today's algorithm can be used to work them all out.

If you are using a data dictionary to build tables, every foreign key represents a dependency, where the child table requires the parent table to exist before it can be built. Today's algorithm can be used to sequence the tables and build them in order.

Another database example is generating code to perform calculations. Some calculations will depend on previous calculations, so your code generator must be able to sequence them all so that the calculations are performed in the proper order.

The examples abvoe are all cases of what mathematicians call a Directed Acyclic Graph. If you do not want to read the entire Wikipedia article, the main points are these:

• We have a set of items. These can be anything you are keeping track of in your database.
• Any item may be connected to zero or more other items.
• The connection is one-way only. So if we say A requires B, we are not saying that B also requires A (in fact it is forbidden).
• There can be no loops (cycles). If A requires B, B may not require A. Further, if A requires B, and B requires C, C may not require A.

Whenever I can, I like to point out that it is very useful to read up on the mathematical foundations of certain programming techniques. We can often pick up very useful insights from those who think of these things at the most abstract level. It is also much easier to get advice from the more abstract-minded database people if you are at least marginally familiar with the mathematical terms.

So now let us proceed to the tables and the code. The tables below show a data dictionary that will be used to generate DDL to build a database:

Table: TABLES

TABLE       | DESCRIPTION            | SEQUENCE
------------+------------------------+---------
ORDERS      | Sales Orders Headers   |  ?
ORDER_LINES | Sales order lines      |  ?
CUSTOMERS   | Customers              |  ?
ITEMS       | Items                  |  ?


Table: DEPENDENCIES

CHILD_TABLE  | PARENT_TABLE
-------------+---------------
ORDERS       | CUSTOMERS
ORDER_LINES  | ORDERS
ORDER_LINES  | ITEMS

The problem here is knowing the safe order in which to build the tables. If I try to build ORDER_LINES before I have built ITEMS, then I cannot put a foreign key onto ORDER_LINES, because ITEMS is not there. In short, I need to know the value of the SEQUENCE column in the example above.

The example above is simple enough that we can work it out by hand. This is actually a good idea, because we want to get an idea of what the answer will look like:

TABLE       | DESCRIPTION            | SEQUENCE
------------+------------------------+---------
ORDERS      | Sales Orders Headers   |  1
ORDER_LINES | Sales order lines      |  2
CUSTOMERS   | Customers              |  0
ITEMS       | Items                  |  0

This answer should be self-explanatory, except maybe for the fact that both CUSTOMERS and ITEMS have the same value. We need to look at that before we can see the code that produces it. Is it OK that two entries have the same value, and how would our program handle that?

The short answer is that it is perfectly OK and natural for two or more entries to have the same value. All this means is that they can be done in any order relative to each other, so long as they are done before the other entries.

In terms of the example, where we want to build these tables in a database, it means that:

• We would query the list of tables and sort by SEQUENCE
• We would loop through and build each table
• We don't care about ITEMS and CUSTOMERS having the same value, they get built in whatever which-way the server gives us the list.

The same concept applies to the other potential examples: manufacturing, software packages, and generating calculations. So long as you follow the sequence, we don't care about items that have the same value.

We are now ready to work out a program that will generate the SEQUENCE column. The basic steps the program must perform are:

1. Initialize the column to -1. A value of -1 means "Not sequenced."
2. Update the column to zero for all items that have no dependencies.
3. Repeat the following action until the affected rows are zero: Update the SEQUENCE column to 1 (then 2, then 3) for all rows that have all of their dependencies sequenced already.
4. Once the command in step 3 is no longer affecting any rows, check for any rows that have -1, these are involved in circular dependencies and we cannot proceed until the user straightens them out.

The first step is very easy, we initialize the table with this command:

UPDATE TABLES SET SEQUENCE = -1;

The next step is also very easy, we mark with a '0' all of the tables that have no dependencies. The basic idea is to find all of the entries that have no entries in DEPENDENCIES.

UPDATE TABLES SET SEQUENCE = 0
 WHERE NOT EXISTS (SELECT child FROM DEPENDENCIES
                    WHERE child = TABLES.TABLE)

Now for the hard part. We now have to execute a loop. On each pass of the loop we are looking for all items whose dependencies have all been sequenced. We will do this over and over until the command is not affecting any rows. It is important that we cannot exit the loop by testing if all rows are sequenced, because a circular dependency will prevent this from happening and we will have an infinite loop.

You can control this loop from client code, but I wrote mine as a Postgres stored procedure. This algorithm turns out to be surprisingly complicated. The UPDATE command below may not be all that self-explanatory. What it works out is:

• Get a list of child tables from the DEPENDENCIES table
• JOIN through to TABLES to look at the SEQUENCE value of their parents.
• Group and check that the minimum value is greater than zero, if it is it means all parents are sequenced and the table can be sequenced.
• Update the SEQUENCE value for the tables we found

CREATE OR REPLACE FUNCTION zdd.Table_Sequencer() RETURNS void AS
$BODY$
DECLARE
    -- Note that rowcount is initialized to be > 0, this makes
    -- the loop work properly
    rowcount integer := 1;
    
    -- This tracks the value we are assigning to SEQUENCE.  We
    -- initialize it to 1 because we already took care of the
    -- the rows that have value 0
    lnSeq integer := 1;
BEGIN
    while rowcount > 0 LOOP
        UPDATE tables set SEQUENCE = lnSeq
          FROM (SELECT t1.CHILD 
                  FROM DEPENDENCIES t1 
                  JOIN TABLES       t2 ON t1.PARENT = t2.TABLE
                 GROUP BY t1.CHILD
                HAVING MIN(t2.SEQUENCE) >= 0
                ) fins
          WHERE TABLES.TABLE = fins.CHILD
            AND TABLES.SEQUENCE = -1;

  lnSeq := lnSeq + 1;
  GET DIAGNOSTICS rowcount = ROW_COUNT;
 END LOOP;
 
 RETURN;
END;
$BODY$
LANGUAGE plpgsql;

The stored procedure above will stop executing once the UPDATE command is no longer having any effect. Once that happens, your final step is to make sure that all rows have a valid SEQUENCE value, which is to say that no entry has SEQUENCE of -1. If any of the rows have that value then you have a circular dependency. You must report those rows to the user, and you can also report the dependencies that are causing the loop.

Sequencing dependencies is a fundamental algorithm that has a lot of use cases in database applications. It is easy enough to accomplish, but the innermost UPDATE command can be a little puzzling when you first look at it. Once you have mastered this algorithm you are on the way to the "big leagues" of database applications such as ERP, MRP and others.

<?xml version="1.0" encoding="utf-8"?>
<mx:Panel xmlns:mx="http://www.adobe.com/2006/mxml" 
 layout="vertical" width="100%"  height="100%"
 title="Upload Files">


 <mx:Script>
  <![CDATA[
   import mx.rpc.AsyncToken;
   import mx.rpc.events.FaultEvent;
   import mx.rpc.events.ResultEvent;
    
   private var refUploadFile:FileReference;

   private var UploadFiles:Array = new Array();
   
   
   // Called to add file(s) for upload
   private function addFiles():void {
    refUploadFile = new  FileReference();
      refUploadFile.browse();
      refUploadFile.addEventListener(Event.SELECT,onFileSelect);
      refUploadFile.addEventListener(Event.COMPLETE,onFileComplete);
   }

   // Called when a file is selected
   private function onFileSelect(event:Event):void {
    UploadFiles.push({  name:refUploadFile.name,
         size:formatFileSize(refUploadFile.size),
         status:"initial"});
    listFiles.dataProvider  = UploadFiles;
    listFiles.selectedIndex = UploadFiles.length - 1;
     
                refUploadFile.load();
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == refUploadFile ) {
                   UploadFiles[i].status = "loaded";
        listFiles.dataProvider  = UploadFiles;
                   break;
                  }
                }
   }

   // Called to format number to file size
   private function formatFileSize(numSize:Number):String {
    var strReturn:String;
    numSize = Number(numSize / 1000);
    strReturn = String(numSize.toFixed(1) + " KB");
    if (numSize > 1000) {
     numSize = numSize / 1000;
     strReturn = String(numSize.toFixed(1) + " MB");
     if (numSize > 1000) {
      numSize = numSize / 1000;
      strReturn = String(numSize.toFixed(1) + " GB");
     }
    }    
    return strReturn;
   }

   
 
     private function onFileComplete(event:Event):void
     {
                refUploadFile = event.currentTarget as FileReference;
                var data:ByteArray = refUploadFile.data;  
                var loader:Loader = new Loader();  
                loader.loadBytes(data);  
                
       var token:AsyncToken = AsyncToken(
                                 remoteUpload.doUpload(data, refUploadFile.name)
                                 );
       
             token.kind = refUploadFile.name;
                          
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == refUploadFile ) {
                   UploadFiles[i].status = "upload";
        listFiles.dataProvider  = UploadFiles;
                   break;
                  }
                }
     }

     private function uploadResultHandler(event:ResultEvent):void
     {
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == event.token.kind ) {
                   UploadFiles[i].status = "finished";
        listFiles.dataProvider  = UploadFiles;
                   break;
                  }
                }
     }

     private function faultResultHandler(event:FaultEvent):void
     {
                for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
                  if( UploadFiles[i].name == event.token.kind ) {
                   UploadFiles[i].status = "error";
        listFiles.dataProvider  = UploadFiles;
                   break;
                  }
                }
     }

   
  ]]>
 </mx:Script>

 <mx:RemoteObject id="remoteUpload" destination="FileUtils" 
  result="uploadResultHandler(event)"
  fault="faultResultHandler(event)"/>
 
 
 <mx:Canvas width="100%" height="100%">
  <mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
   allowMultipleSelection="true" verticalScrollPolicy="on" 
   draggableColumns="false" resizableColumns="false" sortableColumns="false">
   <mx:columns>
    <mx:DataGridColumn headerText="File" width="150" dataField="name" wordWrap="true"/>
    <mx:DataGridColumn headerText="Size" width="50" dataField="size" textAlign="right"/>
    <mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
   </mx:columns>
  </mx:DataGrid>
 </mx:Canvas>
 <mx:ControlBar horizontalAlign="center" verticalAlign="middle">
  <mx:Button id="btnAdd" toolTip="Add file(s)" click="addFiles()" 
   label="Upload Files" width="150"/>
 </mx:ControlBar>
</mx:Panel>

<?xml version="1.0" encoding="utf-8"?>
<mx:Panel xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" 
 width="100%" height="100%" title="Download Files">

 <mx:Script>
  <![CDATA[
   import mx.collections.ArrayCollection;
   import mx.rpc.events.FaultEvent;
   import mx.rpc.events.ResultEvent;
   import mx.rpc.AsyncToken;

   private var UploadFiles:Array = new Array();
   private var UploadFilesColl:ArrayCollection = new ArrayCollection();
   private var fileData:ByteArray = new ByteArray();
   private var fileName:String;

   
     private function uploadResultHandler(event:ResultEvent):void
     {
       if ( event.token.kind == "remoteFileList") { 
               UploadFilesColl = event.result as ArrayCollection;
               for ( var i:int = 0 ; i <  UploadFilesColl.length ; i++ ) {
                 UploadFiles.push({  name:UploadFilesColl[i]
                                  ,  status:"initial"});
               }
               listFiles.dataProvider = UploadFiles;
              } else  {
                 fileData = event.result as ByteArray;
                 fileName = event.token.kind;
                 for ( var b:int = 0 ; b <  UploadFiles.length ; b++ ) {
                  if( UploadFiles[b].name == event.token.kind ) {
                   UploadFiles[b].status = "Ready";
        listFiles.dataProvider  = UploadFiles;
                   break;
                  }
                }

              }
     }

     private function faultResultHandler(event:FaultEvent):void
     {
     }

     private function saveFile(event:Event):void
     {
       var fileReference:FileReference = new FileReference();
       fileReference.save(fileData,fileName);
     }

     private function getRemoteFiles(event:Event):void
     {
       var token:AsyncToken = AsyncToken(remoteDownload.getDownloadList());
             token.kind = "remoteFileList";
     }

     private function getDownload(event:Event):void
     {
       var token:AsyncToken = AsyncToken(
           remoteDownload.doDownload(listFiles.selectedItem.name));
             token.kind = listFiles.selectedItem.name;
     }
  ]]>
 </mx:Script>


 <mx:RemoteObject id="remoteDownload" destination="FileUtils" 
  result="uploadResultHandler(event)"
  fault="faultResultHandler(event)"/>


 <mx:Canvas width="100%" height="100%">
  <mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
   verticalScrollPolicy="on"
   draggableColumns="false" resizableColumns="false" sortableColumns="false">
   <mx:columns>
    <mx:DataGridColumn headerText="File" width="150" dataField="name" wordWrap="true"/>
    <mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
   </mx:columns>

  </mx:DataGrid>
 </mx:Canvas>
 <mx:ControlBar horizontalAlign="center" verticalAlign="middle">
  <mx:Button id="btnList" toolTip="List remote files" 
   width="150" 
   label="Get Remote Files"
   click="getRemoteFiles(event)"/>
  <mx:Button id="btnRetrieve" toolTip="Retrieve file" 
    width="150" click="getDownload(event)" label="Retrieve File"/>
  <mx:Button id="btnSave" toolTip="Save file" 
    width="150" click="saveFile(event)" label="Save File"/>
 </mx:ControlBar>

 
 
</mx:Panel>

package nl.ordina.flex;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

import java.util.ArrayList;
import java.util.List;

public class FileUtils {


    public String  doUpload(byte[] bytes, String fileName) throws Exception
    {
        fileName = System.getProperty("java.io.tmpdir") + "/" + fileName;
        File f = new File(fileName);
        FileOutputStream fos = new FileOutputStream(f);
        fos.write(bytes);
        fos.close();
        return "success";
    }

    public List  getDownloadList()
    {
        File dir = new File(System.getProperty('java.io.tmpdir'));
        String[] children = dir.list();
        List dirList = new ArrayList();
        if (children == null) {
               // Either dir does not exist or is not a directory
           } else {
               for (int i=0; i<children.length; i++) {
                   // Get filename of file or directory
                   dirList.add( children[i]);
               }
           }
        return dirList;
    }

    public byte[] doDownload(String fileName)
    {
        FileInputStream fis;
        byte[] data =null;
        FileChannel fc; 

        try {
            fis = new FileInputStream(System.getProperty("java.io.tmpdir") + "/" + fileName);
            fc = fis.getChannel();
            data = new byte[(int)(fc.size())];
            ByteBuffer bb = ByteBuffer.wrap(data);
            fc.read(bb);
        } catch (FileNotFoundException e) {
            // TODO
        } catch (IOException e) {
            // TODO
        }
        return data;
    }
}

I've been seeing this question come up more and more given recent events. Jan Carlin as posted a response to this.
The bottom line is that one element of the Oracle Application Server in release 11 (OC4J) will now be WLS. This affects Forms in a minimal way since Forms is a C process and only uses the Java container for serving up HTML and for comms management. So, Forms 11g, the next version, will run on a server which uses WLS. It doesn't mean your Forms 9i applications can now be run on some existing WebLogic versions.

Hope that addresses the questions for people.