This issue arises when setting table name with a schema name prefix. For those in the know – this is a must-have if you’re connecting to oracle using a non-owner username (activerecord-jdbc-adapter).

class Model < ActiveRecord::Base
  set_table_name '<schema>.<table>'
end

Now – tracking this down led to
lib/arel/engines/sql/relations/table.rb

def table_exists?
  @table_exists ||= @@tables.include?(name) || engine.connection.table_exists?(name)
end

The @@tables include table names as read from the connection (sans schema name). The comparison with the name always yields false resulting in an instantiation of an empty Header (with no attributes). Hence – alias_table[<attr>] always returned nil and nil.eq is undefined.

Anyways – as a work around (sorry: non tested monkey patch):

in your apps lib folder (provided that it’s auto-loaded) – create the arel_ext.rb

module Arel
  class Table
    def table_exists?
     #checking with only <table_name> rather than <schema_name>.<table_name>
      @table_exists ||= @@tables.include?(name.to_s.gsub(/.*\./, ''))|| engine.connection.table_exists?(name)
    end
  end
end

Reported on activerecord-jdbc-adapter list: http://kenai.com/jira/browse/ACTIVERECORD_JDBC-132

If you move the green parts to become white on their own java files; Your future self will thank you for it.

Or at least you won’t get cursed.

It’s just to tell the horror story of one of our down-the-drain projects.

The client came with an old product that he needed to add new features to. The product does, what is best described as CRUD operations. Nothing challenging, nothing difficult. It maintains a set of data for various client in a certain business domain. Their business model (at least what they’re trying to do) is through ad and subscription revenue. They were trying to move the business forward through enhancing the provided service.

The only challenge can best be described as that the product was a pure mess.

It has been built using (last time I counted) 7 different Java frameworks, some redundant, some obsolete. Apparently it has been the greatest learning experience for few individuals. The product took 8 years in the making, 4 different teams (non remained with the project), 14,000+ files, absurdly normalized 100+ tables database, absolutely 0 documents, No unit/function/otherwise tests to reach its current state.

To give some example of code horror that we had to go through, some Java classes contained business logic, HTML code, display logic, data access mechanisms, hard coded urls. The objects were then instantiated from within JSP pages (with lots of other embedded Java business logic/code) and passed parameters and servlet controls.

This is not to mention the build scripts that took 3 hours to update code off of the CVS, then threw numerous errors during the “real’ build.

That’s in addition to the project tree which was in a state of absolute mess (40+ different individual modules, with some exact modules placed in different locations).

And have I mentioned the “wrapper” PHP application that was delivering a CMS-like functionality (another set of mess, with no cross-application awareness of any kind).

Again, the product didn’t do anything challenging. Just basic CRUD and a couple background processes.

Our initial attempt was, of course, to build on top of the insanely absurd code-base, but after few days, we’ve decided (us, client, operations) that it might worth to venture into a new platform, in order to make it easier (and cheaper) to deliver new business service and at the same time, incrementally migrate features into a more robust code base.

Few months into the making; including the client formulating his requirement and reverse engineering the legacy system, we had our first release of the new business features (including the integration with the original application, modelling 70% of the legacy schema, a streamlined version of few original functions, documenting finds of the original application).

Few more months of client acceptance testing (and repetitive requests from our part for a feedback), client vacations, and [seemingly] client running out of budget, the client finally came back to us deciding that our solution was not accepted.

I frankly didn’t know whether to laugh or cry.

Despite the fact that the client admits, in his own words, the original Java application is a bag of “s$%t”, he refuses any attempt from our side to tell him that his application is non-maintainable.

He decided (and probably promised by some other individuals) to monkey-patch the code base that he has. He, of course, threw our choice of Ruby into the bag of reasons not to pursue this further.

Although I can defend our decision to resort to an incremental migration, and taking Rails as our vehicle quite well, yet, I now believe that the choice of technology should be the least of his worries. The business decision of incremental migrations (or even rather a rewrite) remains the optimum choice in my opinion, whether it’s done in Ruby, Java, PHP or brain*^%&.

The moral of the story is: As long as you care, never be a door mat, insist on getting your ideas through, always believe that you’ve been hired not for your typing speed, but for your intellectual abilities and what they can bring to the business.

require 'rubygems'
require 'hpricot'
require 'mechanize'

class WelcomeController < ApplicationController
...

  def login
    agent = WWW::Mechanize.new
    page = agent.get('http://example.com')
    login_form = page.form('loginForm')
    login_form.username = params['username']
    login_form.password = params['password']
    page = agent.submit(login_form, login_form.buttons.first)
    cookie = agent.cookies.first
    cookies["JSESSIONID"] = {:value => pet_cookie.value, :path => '/', :domain => 'example.com'}
  end

...

end

Of course this is just the basic stuff (no error handling, no response checking, no cookie review, …)

The idea is to use Mechanize to simulate the browser actions from within the controller, log-in to the second application, set up a first-application session cookie with the same name/value pair as that of the returned cookie from the first application. I’m not sure that this covers all the basis but it’s not a bad start. Muhammad has also mentioned the idea of having Rails session cookies written with the same name/value pair as those of the Java application.

Thoughts?

Anyways, I think some of the guys were entrigued enough to, at least, give it a try. Being mainly at a PHP shop, I’m still not qualified to do a full comparison, but, from the little time I spent with PHP (so far), I’m becoming even more attached to the beloved Rails.

I think I’m becoming more of a Rails fanatic – comparing every code and architecture I come across to Rails. I find myself asking, how ‘that’ could be done in Rails. How could ruby shine in such a situation. How elegant would it be to implement that in Rails. How much less lines of code I could reach that same setup.

My next project is a minor refactoring of what seems like a complex Java project (read: reusable components). I’m still exploring the source tree. I can’t help but to wonder about the size of the project, and what it ‘actually’ do . I’m having a hard time forcing myself ‘NOT’ to think of it as a Rails rewrite opportunity. Hope I can manage

I'm a recent convert to Ruby on Rails. My organization has several (over 50) iSeries machines on our WAN. As MIS manager, I plan to start pushing RoR development in the near future but really need that DB2 iSeries connector running. Please escalate the development effort. Thanks!

So, provided the info is real, and skipping the part that a connector/adapter is not ready up until now, an organization with over 50 iSeries machines (most probably legacy) will be pushing RoR as a part of its technology stack. That's big.

A reply from “Milhouse”

It's not that hard to hack up an adapter if you don't mind using the DBI:ADO adapter (see my earlier post). I've used it experimentally with success. Another option I plan to explore is to use JRuby with their JDBC-ActiveRecord with the existing iSeries JDBC drivers. This has the added advantage of easy integration with Java libraries.

I think it's time to give JRuby a try.

powered by performancing firefox

With 290+ members and only around 10 attending the first meeting, the group needs a hell lot of marketing. There's also a good chance the Java developers around aren't that interested in such groups/meeting/events. I experienced the same lack of interest when trying to establish a meeting among Alexandria Java User group. That said, I think EGJUG have a better chance given the current mindset and experience of moderators, and core team.

There's an initial plan to invite a different speaker each month, so, I'll be trying to reach out for some experts for Java-related talks.

If you have an interest in either talking or attending, or have any other suggestions in that respect, I'm all ears and eyes.

Create two new Recent Entries and Comments template pages.

Recent Entries template:


<ul>

Recent Comments template:


#if($website.allowComments)

Include these pages in their respective locations in the main weblog template through #includePage(“<_templateName>”)

It’s just a quick hack, there are better ways to do it (macros), and the pervious method will limit the number of entries according to the page you’re on (try clicking any of the old entries and check the new list) – but these will work for most of the cases. Also, there’s this showRecentEntries macro definition that can be used – but I haven’t tried it. HTH.