We understand that some commercial languages (e.g. .NET and ColdFusion) and PHP are implementing frameworks like Rails.  We are stoked that Ruby on Rails is amongst the pioneers and that the power of the language makes it a pleasure to use.

drop function myuser.DateToJ!

CREATE function myuser.DateToJ (RealDate date)
    returns decimal(8,0)
    language sql
    deterministic
    no external action
begin atomic
   if RealDate is null then
      return 0;
   else
      return ((Year(RealDate) - 1900) * 1000) + DayOfYear(RealDate);
   end if;
end!

select myuser.DateToJ(date('2008-11-18'))
from myuser.dual!

--#SET DELIMITER !
drop function myuser.JDEConvert!

CREATE function myuser.JDEConvert(Item decimal(10,0), FromUOM varchar(3),
                                  ToUOM varchar(3), Units decimal(15,7))
   returns decimal(15,7)
   language sql
   not deterministic
   reads sql data
begin atomic

   declare PrimaryUnits decimal(15,7);
   declare ToUnits decimal(15,7);

   /*declare exit handler for sqlexception
      return null;*/

   /* This is for the sake of speed mainly */
   if Units = 0 then
      return 0;
   end if;
   if FromUOM = ToUOM then
      return Units;
   end if;

   /* -----------------------------------------------------------------
      we know we don't have any conversion directly between the from unit
      and the to unit, so what we do is look for a conversion like so...
      FromUOM to PrimaryUOM to ToUOM
      ----------------------------------------------------------------- */
   for cfF41002 as
      select f.umum fum, f.umrum frum, round(f.umconv/10000000,7) fconv, round(f.umcnv1/10000000,7) fcnv1,
             t.umum tum, t.umrum trum, round(t.umconv/10000000,7) tconv, round(t.umcnv1/10000000,7) tcnv1
        from f41002 f join F41002 t on t.umitm = f.umitm
       where f.umitm = Item
         and FromUOM in (f.umum, f.umrum)
         and ToUOM in (t.umum, t.umrum)
   do
       /* This could be slightly simplified, but this way is easier to read I think. */
       if fum = FromUOM then
          set PrimaryUnits = Units * fcnv1;
       else
          set PrimaryUnits = (Units / fconv) * fcnv1;
       end if;

       if tum = ToUOM then
          set ToUnits = PrimaryUnits / tcnv1;
       else
          set ToUnits = (PrimaryUnits * tconv) / tcnv1;
       end if;

       return ToUnits;

       /*return ToUnits;*/

   end for;

   return null;

end!

select imsrtx,
       '1' || imuom1 || ' =', JDEConvert(imitm, imuom1, 'LB', 1) || ' lbs.',
       '1' || imuom2 || ' =', JDEConvert(imitm, imuom2, 'LB', 1) || ' lbs.'
  from f4101

(In the past, we had a function that found the requested conversion by recursively searching direct conversions till it found a path between the From UOM and the ToUOM. We all know recursion is more fun and usually requires less code. In this case the recursive method was less efficient and created more problems than it solved, so we sadly had to rewrite to this method, which we are just as proud of.)

-- We have to set the delimiter to ! so we can use
-- ; inside our function.  This is an intelligent comment
-- just for DB/2, but don't forget to tell your SQL tool to use !.
--#SET DELIMITER !
drop function myuser.JToDate!

CREATE function myuser.JToDate (JDEDate decimal(8,0))
    returns date
    language sql
    deterministic
    no external action
begin atomic
   if JDEDate = 0 then
      return null;
   else
      return date(char(1900000 + Round(JDEDate, -3) + (JDEDate - Round(JDEDate, -3))));
   end if;
end!

select JToDate(108098), JToDate(0), JToDate(imupmj)
from F4101!

I recommend the DB/2 SQL Cookbook as a pleasant mix of examples and syntax flows from which to learn.

- Adam

Now when you are using gvim, you are editing files faster than ever.  But when you are using grep and sed and so on, you get a request to remove commas from the names of 20,000 files and you say “with pleasure.”dir /b | grep , | \
sed -e "s/^.*/\d034&\d034 /;h" -e "s/,/_/;x" \
-e "s/^.*/mv &/;G" -e "s/\n//"

• We used dir at the beginning because it runs faster than ls in a Windows directory with 20,000 files.  One could just as easily use ls.
• Even though we could have done the same thing with sed, we used grep just to take away one sed command.
• We broke the sed commands into pieces because we were having problems with how Windows was passing arguments to sed.  This also makes the line [slightly] more readable.
• The sed edits operate on this wise:
  • Add quotation marks to the beginning and the end of the file name.
  • Save the resulting string in a buffer (clipboard).
  • Replace commas in the file name with underscores.
  • Exchange the fixed file name with the buffer.  Now we’re working with the original file name.
  • Add the mv command before the original file name.
  • Paste the fixed filename after the mv and original file name.

Redirect this output to a file and you have a script to remove all of those pesky commas.  Sweet?  We think so.

SELECT field1, field2, field3, field4, field5
FROM table1 a inner join table2 b on field1 = field2 and field3 = field4
WHERE field1 = 'junk' and field3 = 'that' and field5 is not null

You could see this:

select * from (
SELECT field1, field2,
       field3, field4, field5
  FROM table1 a inner join table2 b on field1 = field2
                                   and field3 = field4
 WHERE field1 = 'junk'
   and field3 = 'that'
   and field5 is not null
) as a

The only problem is that Access gets confused about the parenthesis around the view and replaces them with brackets. For us, replacing the brackets with parenthesis is a better situation than manually beautifying the code all over again every time we open it.

Let’s say you have a custom table [F550001] that has a column [URRF], and you need to find all programs that use the F550001.URRF. Well, you may have 50 custom programs that use F550001 and there may be 250 programs, native and custom, that use the alias URRF. You can see the difficulty in searching through 50 programs to find 5 that reference F550001.URRF.

If, however, you take the 50 custom programs that reference F550001 and export them to the spreadsheet program of your choice and then export the 250 programs that reference the URRF to another spreadsheet, you can filter the 50 references to F550001 down to only those programs that also reference URRF. Now, you still may have a few extra programs in your list — programs that don’t reference F550001.URRF — but you now have a much smaller list to work from.