Код примерно следующий:

var form = new ExtJS.FormPanel({
  url: "fileupload",
  fileUpload: true,
  items: [...],
  ...
});

def fileupload
  fname = params[:filename]
  if File.exists? fname
    #...
    render :json=>{:success=>true, :message=>"Файл загружен успешно!"}
  else
    render :json=>{:success=>false, :message=>"Файл не найден"}
  end
end

Все это оказывается из-за того, что ExtJS не может отправить файл на сервер с помощью Ajax. Он создает скрытый iframe, отправляет данные формы стандартным способом и помещает результат в скрытый iframe. Но браузер почему-то не понимает возвращаемые ему данные в json формате и типом html/application .
Решение проблемы напрашивается само сабой: заменить тип возвращаемого результата на текст.

  render :text=>{:success=>false, :message=>"Файл не найден"}.to_json

Все. Надеюсь кому-нибудь эта заметка помогла.
Удачи!

Maybe there a many better tools for object relational mapping, but i don’t care
It’s simple. And it’s worked for me.
Ok, let’s start.

What do we have?

We have a database (IBM DB2 Express-C) with many tables. This post was written for DB2, but many other databases may be used if you write some code. I’ll explain how to make an adapter later.

CREATE TABLE WP.COMPANY (
  COMPANY_ID INTEGER  NOT NULL GENERATED ALWAYS AS IDENTITY,
  NAME VARCHAR (255) NOT NULL,
  CONSTRAINT PRIMARY KEY (COMPANY_ID),
  CONSTRAINT UNIQUE (NAME)
);

CREATE TABLE WP.TEAM (
  COMPANY_ID INTEGER  NOT NULL,
  TEAM_ID INTEGER  NOT NULL GENERATED ALWAYS AS IDENTITY,
  NAME VARCHAR (255) NOT NULL,
  CONSTRAINT PRIMARY KEY (COMPANY_ID, TEAM_ID),
  CONSTRAINT UNIQUE (COMPANY_ID, NAME),
  CONSTRAINT FOREIGN KEY (COMPANY_ID)
     REFERENCES WP.COMPANY ON DELETE RESTRICT
);

CREATE TABLE WP.PERSON (
  COMPANY_ID INTEGER  NOT NULL,
  TEAM_ID INTEGER  NOT NULL GENERATED ALWAYS AS IDENTITY,
  NAME VARCHAR (255) NOT NULL,
  CONSTRAINT PRIMARY KEY (COMPANY_ID, TEAM_ID),
  CONSTRAINT UNIQUE (COMPANY_ID, NAME),
  CONSTRAINT FOREIGN KEY (COMPANY_ID)
     REFERENCES WP.COMPANY ON DELETE RESTRICT
);

What do we need?

We have a tables named as company, team and person. And we need use them like that:

    XDict dict = new XDict("Database=SAMPLE;User ID=test;password=secret;Server=localhost:50001");
    Company comp = dict.Companys.Single(c => c.Name == "IBM");
    Teams[] transTeams = comp.Teams.Where(t =>
        t.Persons.Contains(p =>
            p.Name == "Armin van Buuren"));
    ...

We need a tool!

I think we need a tool. This tool must generate all classes and using it must be simple. Like this:

generator wp.company db2 "Database..." Staff "d:\work\gen1"

• wp.company – the table name in database
• db2 – type of database
• “Database…” – connection string
• Staff – Target namespace
• “d:\work\gen1″ – Output directory

All done!

Stop! We have a three table! How about team and person?
Simple: database must know about all relations. And tool must get this info and generate three files:
Company.cs, Team.cs and Person.cs.

Ok, let’s make this generator!

How?

We write class XClassGen that use MetaReader for generate classes. It will connect to the database and will read structure of the database from system catalog tables.

MetaReader

First of all it is necessary to create an abstract class MetaReader.

    public abstract class MetaReader
    {
        public MetaReader(string connectionString)
        {
            this.ConnectionString = connectionString;
            this.PropNameAliases = new Dictionary<string, ReferenceNames>();
        }
        ...
        protected abstract MetaTable ReadTable(string schemaName, string tableName);
        protected abstract MetaColumn[] ReadColumns(MetaTable table);
        protected abstract MetaProp[] ReadProps(MetaTable table);

        public Dictionary<string, ReferenceNames> PropNameAliases { get; private set; }
        ...

MetaTable class will be used for keeping ShemaName and TableName.

    public class MetaTable
    {
        internal MetaTable(string schemaName, string tableName)
        {
            this.SchemaName = schemaName;
            this.TableName = tableName;
        }
        public string SchemaName { get; private set; }
        public string TableName { get; private set; }
    }

Sometimes the code may say about self better than writer

    public class MetaColumn
    {
        internal MetaColumn(string name, string dbName, string columnType, bool nullable,
            short columnSeq, bool isPrimaryKey, short primaryKeySeq)
        {
        ...
        }

        public string Name { get; private set; }
        internal string DbName { get; private set; }
        public string ColumnType { get; private set; }
        public bool Nullable { get; private set; }
        public short ColumnSeq { get; private set; }
        public bool IsPrimaryKey { get; private set; }
        public short PrimaryKeySeq { get; private set; }
    }

MetaProp. In fact this class reflect a referential constraints.

    public class MetaProp
    {
        internal MetaProp(string name, string[] selfColumns, ...) {...}

        public string Name { get; private set; }
        public MetaTable OtherTable { get; private set; }
        public string[] SelfColumns { get; private set; }
        public string[] OtherColumns { get; private set; }
        public bool IsCollection { get; private set; }
    }

DB2MetaReader

Now we are creating an adapter for IBM DB2 database.

    public sealed class DB2MetaReader : MetaReader
    {
        public DB2MetaReader(string connectionString) : base(connectionString) { }

        protected override MetaTable ReadTable(string schemaName, string tableName)
        {
            string sql = string.Format(@"
                select 
                    table_schem as schema_name, 
                    table_name as table_name, 
                    table_type as table_type
                from 
                    sysibm.sqltables 
                where 
                    table_type = 'TABLE' and
                    table_schem = '{0}' and
                    table_name = '{1}'", new object[] { schemaName, tableName });
            
            DataTable tbl = GetDataTable(sql);

            if (tbl.Rows.Count < 1)
            {
                throw new Exception("Table '" + schemaName + "." + tableName + "' not found.");
            }

            return new MetaTable(schemaName, tableName);
        }

        protected override MetaColumn[] ReadColumns(MetaTable table)
        {
            List<MetaColumn> columns = new List<MetaColumn>();
            string sql = string.Format(@" 
                select
                    trim(c.colname) as field_name,
                    trim(coalesce(t.sourcename, c.typename)) as field_type,
                    c.colno as field_seq,
                    c.length as field_length,
                    trim(c.nulls) as has_nulls,
                    k.colseq as pk_seq
                from
                    syscat.columns c  
                        inner join syscat.datatypes t on  
                            t.typeschema = c.typeschema and  
                            t.typename = c.typename  
                        left outer join syscat.tabconst tc on
                            tc.tabschema = c.tabschema  and
                            tc.tabname = c.tabname and
                            tc.type = 'P'
                        left outer join syscat.keycoluse k on
                        	k.tabschema = tc.tabschema and
                        	k.tabname = tc.tabname and
                        	k.colname = c.colname and
                            k.constname = tc.constname 
                where 
                    c.tabschema = '{0}' and
                    c.tabname = '{1}'", new object[] { table.SchemaName, table.TableName });

            DataTable tbl = GetDataTable(sql);

            foreach (DataRow row in tbl.Rows)
            {
                bool nullable = (string)row["HAS_NULLS"] == "Y";
                bool isPrimaryKey = !(row["PK_SEQ"] is DBNull);
                short pkSeq = -1;
                if (isPrimaryKey)
                {
                    pkSeq = (short)row["PK_SEQ"];
                }
                columns.Add(new MetaColumn(
                    ((string)row["FIELD_NAME"]).CheckThis(),
                    (string)row["FIELD_NAME"],
                    GetTypeNameByDB2TypeName((string)row["FIELD_TYPE"], nullable),
                    nullable, (short)row["FIELD_SEQ"],
                    isPrimaryKey, pkSeq));
            }

            return columns.OrderBy(c=>c.ColumnSeq).ToArray();
        }

        protected override MetaProp[] ReadProps(MetaTable table)
        {
        ...
        }
    ...
    }

Generator

    public class XClassGen
    {
        public XClassGen(MetaReader reader, string tablesToGen, string removePrefix, string namespaceName, string saveToFolder)
        {
        ...
        }
        ...
        public void DoGen()
        {
            tables = new List<MetaTable>();
            string[] tableNames = TablesToGen.Split(';');
            foreach (string tName in tableNames)
            {
                string[] partName = tName.Split('.');
                if (partName.Length == 2)
                {
                    GenTable(Reader.GetTable(partName[0], partName[1]));
                }
                else
                {
                    throw new Exception("Wrong Table Name: " + tName);
                }
            }
            GenDict();
            Console.WriteLine();
            Console.WriteLine("Done.");
        }

        private void StoreClass(string className, string content)
        {
            string fileName = SaveToFolder.TrimEnd('\') + "\" + className + ".cs";
            using (StreamWriter sw = new StreamWriter(fileName))
            {
                sw.Write(content);
                sw.Flush();
                sw.Close();
            }
            Console.WriteLine("File '" + fileName + "' was saved.");
        }

        private void GenTable(MetaTable table)
        {
            if (tables.Contains(table))
            {
                return;
            }
            tables.Add(table);
            MetaColumn[] columns = Reader.GetColumns(table);
            MetaProp[] props = Reader.GetProps(table);

            string className = table.TableName.Beauty(RemovePrefix);

            string res = "using System;\r\nusing System.Collections.Generic;\r\n";
            res += "using System.Linq;\r\nusing System.Text;\r\n\r\nnamespace " + NamespaceName + "\r\n{\r\n";
            res += "\tpublic class " + className + "\r\n\t{\r\n\t\tinternal " + className + "(XDict dict, ";
            res += string.Join(", ", columns.Select<MetaColumn, string>(c =>
                c.ColumnType + " " + c.Name.Beauty().FirstCharLower()).ToArray()) + ")\r\n\t\t{\r\n";
            res += "\t\t\tthis.Dict = dict;\r\n\r\n";
            res += string.Join("", columns.Select<MetaColumn, string>(c =>
                "\t\t\tthis." + c.Name.Beauty() + " = " + c.Name.Beauty().FirstCharLower() + ";\r\n").ToArray());

            string loadEvs = "";
            string propsBlock = "";

            foreach (MetaProp pr in props)
            {
                string prName = pr.Name.Beauty(RemovePrefix);
                string prFldName = prName.FirstCharLower();
                string prLoadFn = prFldName + "_OnLoad";
                string prType = pr.OtherTable.TableName.Beauty(RemovePrefix) + (pr.IsCollection ? "[]" : "");
                res += "\r\n\t\t\tthis." + prFldName + " = new XLazyLoad<" + prType + ">();\r\n";
                res += "\t\t\tthis." + prFldName + ".OnLoad += new LoadEventDelegate<" + prType + ">(" + prLoadFn + ");\r\n";

                loadEvs += "\r\n\t\tvoid " + prLoadFn + "(out " + prType + " valueForLoad)\r\n\t\t{\r\n";
                loadEvs += "\t\t\tvalueForLoad = Dict." + pr.OtherTable.TableName.Beauty(RemovePrefix) + "s.Where(x => ";
                List<string> pairs = new List<string>();
                for (int i = 0; i < pr.SelfColumns.Length; i++)
                {
                    pairs.Add("(x." + pr.OtherColumns[i].Beauty() + " == this." + pr.SelfColumns[i].Beauty() + ")");
                }
                loadEvs += "\r\n\t\t\t\t" + string.Join(" && \r\n\t\t\t\t", pairs.ToArray()) + ")" +
                    (pr.IsCollection ? ".ToArray()" : ".SingleOrDefault()") + ";\r\n\t\t}\r\n";

                propsBlock += "\r\n\t\tprivate XLazyLoad<" + prType + "> " + prFldName +
                    ";\r\n\t\tpublic " + prType + " " + prName + "{ get { return " + prFldName + ".Value; } }\r\n";
            }

            res += "\t\t}\r\n\r\n";

            res += "\t\tpublic XDict Dict { get; private set; }\r\n";

            res += loadEvs;

            res += "\r\n\t\t" + string.Join("\r\n\t\t", columns.Select<MetaColumn, string>(c =>
                "public " + c.ColumnType + " " + c.Name.Beauty() + " { get; private set; }").ToArray()) + "\r\n";

            res += propsBlock;

            res += "\r\n\t\tpublic string ID\r\n\t\t{\r\n\t\t\tget\r\n\t\t\t{\r\n\t\t\t\treturn ";
            res += string.Join(" + \".\" + ", columns
                .Where(c => c.IsPrimaryKey)
                .OrderBy(oc => oc.PrimaryKeySeq)
                .Select<MetaColumn, string>(mc => "this." + mc.Name.Beauty() + ".ToString()")
                .ToArray());
            res += ";\r\n\t\t\t}\r\n\t\t}\r\n";
            
            res += "\r\n\t\tpublic override string ToString()\r\n\t\t{\r\n\t\t\treturn ID;\r\n\t\t}\r\n";

            res += "\t}\r\n}";

            StoreClass(className, res);

            foreach (MetaProp pr in props)
            {
                GenTable(pr.OtherTable);
            }
        }
        
        private void GenDict()
        {
            ...
            StoreClass("XDict", res);
        }
    }
}

Private method GenDict() will generate one more class called XDictto the output directory. This class will read the data from database and create objects and collections for Company, Team and Person classes.

Full source code I can upload on sourceforge. If anybody needs that.