select dob,
    floor(datediff(day, dob, getDate()) / 365.25) as age
    from personnel

Download this file and put it in AquaDataStudio.app/Content/Resources/Java.

Someone else came up with this solution, but I have no idea of the original source.

Here’s a script to fix that…

Launch the Apple Script Editor, and create a new script. Enter the following in the script…

-- Example list of processes to ignore: {"xGestures"} or {"xGestures", "OtherApp", ...}
property processesToIgnore : {"GeekTool"}

-- Get the size of the Display(s), only useful if there is one display
-- otherwise it will grab the total size of both displays
tell application "Finder"
	set _b to bounds of window of desktop
	set screen_width to item 3 of _b
	set screen_height to item 4 of _b
end tell

tell application "System Events"
	set allProcesses to application processes
	set _results to ""
	repeat with i from 1 to count allProcesses
		set doIt to 1
		repeat with z from 1 to count processesToIgnore
			if process i = process (item z of processesToIgnore) then
				set doIt to 0
			end if
		end repeat

		if doIt = 1 then
			tell process i
				repeat with x from 1 to (count windows)
					set winPos to position of window x
					set _x to item 1 of winPos
					set _y to item 2 of winPos
					set winPos to size of window x
					set _width to item 1 of winPos
					set _height to item 2 of winPos

					if (_x < 0 or _y < 0 or _x > screen_width or _y > screen_height) then
						set position of window x to {0, 22}
					end if
					if (_width > screen_width or _height > screen_height) then
						set size of window x to {screen_width - 100, screen_height - 100}
					end if
				end repeat

			end tell
		end if
	end repeat
end tell

Save the file, and then export as an application. Do File –> Save As, and change the File Format to be Application. Once completed, you now have an executable (double-clickable) program that will run the script.

Note that I got this code from somewhere like this, modified slightly for my use.

It’s also worth mentioning that someone else has already fixed this problem with a free app named Forget-Me-Not.

Here’s a workaround…

This is a more thorough explanation of a previous post. In lieu of an GV app, I figured out a quick and easy way to dial your most frequent contacts using no more than 2 clicks. All we’re doing is adding a bookmark to your iPhone home page that links to a contact’s unique URL in your GV address book. Ready?

1. Load up the mobile GV site (https://www.google.com/voice/m). It works fine in Firefox — it doesn’t redirect to the non-mobile version like other Google sites.

2. Find your desired favorite in your contact list. Let’s use “Mom” for our example. Each contact has its own unique URL – something like https://www.google.com/voice/m/contact/793238491687864. Copy this link to your clipboard.

3. Use your favorite photo editing software to find the perfect headshot of mom. Crop it so it’s EXACTLY a square (I use Picasa).

4. Resize mom’s picture so it’s 57 x 57, and save as a PNG to your desktop. (I used http://www.resize2mail.com/advanced.php)

5. Fire up http://webclipicons.info/ Upload your 57 x 57 PNG, give it the shortcut name “mom” and paste the GV unique contact URL from step 2 into the “shortcut URL” prompt. Put in your email address, and uncheck “make public.” Hit “create shortcut.”

6. Check your iPhone email. You should receive a message with link — click on it. Safari should launch. Bookmark that page to your home screen. Your mom’s smiling face should appear along with your fart and other useless apps.

7. When it’s time to call mom, click on her face. Her contact page in your GV account will load in Safari. You can then call or SMS any number that you have stored for her.

via NyQuil.org.

Want to change your fn key? Use DoubleCommand.

First, go to Firefox’s about:config page… enter “about:config” in the location bar:

Click past the warning, and enter a filter-text of “gesture” to see the various multi-finger gestures and their commands.

Here are the possible values you can put in the Value, and thus which action you will trigger with the gesture.

• cmd_copy
• cmd_cut
• cmd_paste
• cmd_selectAll
• cmd_selectNone
• cmd_copyLink
• cmd_copyImageLocation
• cmd_copyImageContents
• cmd_scrollTop
• cmd_scrollBottom
• cmd_scrollPageUp
• cmd_scrollPageDown
• cmd_scrollLineUp
• cmd_scrollLineDown
• cmd_scrollLeft
• cmd_scrollRight
• cmd_selectCharPrevious
• cmd_selectCharNext
• cmd_wordPrevious
• cmd_wordNext
• cmd_selectWordPrevious
• cmd_selectWordNext
• cmd_beginLine
• cmd_endLine
• cmd_selectBeginLine
• cmd_selectEndLine
• cmd_selectLinePrevious
• cmd_selectLineNext
• cmd_selectPagePrevious
• cmd_selectPageNext
• cmd_selectMoveTop
• cmd_selectMoveBottom

• cmd_paste
• cmd_pasteQuote
• cmd_delete
• cmd_deleteCharBackward
• cmd_deleteCharForward
• cmd_deleteWordBackward
• cmd_deleteWordForward
• cmd_deleteToBeginningOfLine
• cmd_deleteToEndOfLine
• cmd_delete
• cmd_deleteCharBackward
• cmd_deleteCharForward
• cmd_deleteWordBackward
• cmd_deleteWordForward
• cmd_deleteToBeginningOfLine
• cmd_deleteToEndOfLine
• cmd_scrollTop
• cmd_scrollBottom
• cmd_moveTop
• cmd_moveBottom
• cmd_selectTop
• cmd_selectBottom
• cmd_lineNext
• cmd_linePrevious
• cmd_selectLineNext
• cmd_selectLinePrevious
• cmd_charPrevious
• cmd_charNext
• cmd_selectCharPrevious
• cmd_selectCharNext
• cmd_beginLine
• cmd_endLine
• cmd_selectBeginLine
• cmd_selectEndLine
• cmd_wordPrevious
• cmd_wordNext
• cmd_selectWordPrevious
• cmd_selectWordNext
• cmd_scrollPageUp
• cmd_scrollPageDown
• cmd_scrollLineUp
• cmd_scrollLineDown
• cmd_movePageUp
• cmd_movePageDown
• cmd_selectPageUp
• cmd_selectPageDown

The list is from Mozilla’s Website.

You can also use these commands, which I figured out from trial and error:

• Browser:Home – takes you to your home page
• Browser:PrevTab
• Browser:NextTab
• Browser:BackOrBackDuplicate – equivalent to back button
• Browser:ForwardOrForwardDuplicate
• Browser:Reload

If you make a mistake, you can right-click on the setting and “reset” to the original configuration value.

You can use the steps from this article by Rafe Needleman. The process includes using Yahoo Pipes to get the RSS feed, translate it, and then create new content output from that. Not horribly complicated, and quite a nice trick to know about.

Note that Yahoo’s Pipes has moved the Babelfish translation into the deprecated list… not sure how long the functionality will continue to be supported.

First up, with any entity, you need to add an @Id annotation to a field, I typically use a Long field.

package test.model;

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name="test_table")
public class TestTable implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @Column(name="test_table_id")
    private Long id;

    // getters & setters
}

All is good and well, until we want to persist new TestTable objects. Now we need a @GeneratedValue annotation… you can use a variety of strategies: GenerationType.AUTO, IDENTITY, SEQUENCE, or TABLE. Auto will have Hibernate guess at which version is best for your database type (e.g., a sequence for Oracle, an identity for MS SQL).

One requirement I typically have is that the application code and resultant data structure be database agnostic, and more specifically, have the same index strategy despite different databases. So, we can define a strategy that will be implemented the same regardless of database type.

For a TABLE generation strategy, you can simply specify the strategy. This will result in a table “hibernate_sequences” and a caching size of 10 (I think).

@Id
@Column(name="test_table_id")
@GeneratedValue(strategy=GenerationType.TABLE)
private Long id;

This is fine, but Hibernate is actually caching the index number for you, and only writing out the index to table every 10 or so inserts. We will want to change that (despite the performance hit) if we have anything that may not be using Hibernate to access these indexes.

The following will do the same as above (hibernate_sequences table), but flush the index out on every increment of the index. The “generatorName” below is just an arbitrary name that pairs the two annotations.

@Id
@Column(name="test_table_id")
@GeneratedValue(strategy=GenerationType.TABLE, generator="generatorName")
@TableGenerator(name="generatorName", allocationSize=1)
private Long id;

Want more control? It’s available… Here we’ll specify the table to put the sequences into, in case there was an existing table strategy used in some other project that you’d like to work with.

@Id
@Column(name="test_table_id")
@GeneratedValue(strategy=GenerationType.TABLE, generator="generatorName")
@TableGenerator(name="generatorName", table="TableID",
				pkColumnName="tablename", // TableID.TableName (value = table_name, test_table, etc.)
				valueColumnName="id", // TableID.ID (value = 1,2,3,etc.)
				allocationSize=1 // flush every 1 insert
)
private Long id;

We can also use a custom coded IdentifierGenerator when using Hibernate. The class MyIdGenerator extends IdentifierGenerator in the example below. I also chose to implement Configurable so I could pass the table name into the generator.

// new imports
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
// annotations for ID field
@Id
@Column(name="test_table_id")
@GeneratedValue(generator="UniqueIdGenerator")
@GenericGenerator(name="UniqueIdGenerator", strategy="test.util.MyIdGenerator",
	parameters = { @Parameter(name="tableName", value="test_table") } )
private Long id;

And here is the ID generator…

package test.util;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.id.Configurable;
import org.hibernate.id.IdentifierGenerator;
import org.hibernate.type.Type;

public class MyIdGenerator implements IdentifierGenerator, Configurable {
	private String tableName;

    public void configure( Type arg0, Properties props, Dialect arg2 )
            throws MappingException {
        setTableName( props.getProperty( "tableName" ) );
    }

    public Serializable generate( SessionImplementor session, Object arg1 )
            throws HibernateException {
        // we want to open a new connection / transaction
        Connection conn = session.getBatcher().openConnection();

        Serializable id = null;
        try {
            id = new IdGenerator().generate( conn, tableName );
        } catch( SQLException e ) {
            throw new HibernateException( e );
        } finally {
            session.getBatcher().closeConnection( conn );
        }
        return id;
    }

    // getter & setter for the configurable parameters
    public String getTableName() {
        return tableName;
    }
    public void setTableName( String tableName ) {
    	this.tableName = tableName;
    }
}