Archive
More Google Geocoding
Ok, for those who liked the prior post on Google geocoding via HTTP, you will enjoy this as well. It builds on what was done in that example but retrieves even more information from google.
Before we used an output type of CSV and that only gave us back the LATITUDE and LONGITUDE. But there is more information that we can derive from the geocoding service if we use a different output type. If we request the result in XML, then we are given the complete address as well as the longitude and latitude. But we have to do a little extra work to parse out the results.
I have written a PL/SQL object type to do just that. Why an object type and not a Package? Personal preference. In this case, it just seemed to feel right to make it an object. With some simple code factoring, it could easily be converted into a package. But since most PL/SQL developers don’t code object types, thought it might be interesting.
Let’s take a look at the object’s specification.
create or replace
type google_geocode_type as object (
-- Attributes
response xmlType,
search varchar2(32767),
-- Constructor Methods
constructor function google_geocode_type(
p_search varchar2 default null ) return self as result,
-- Execute Geocode
member procedure execute(
p_search varchar2 default null ),
-- Getter Routines
member function get_result_count return number,
member function get_geometry(
p_sequence number default 1 ) return sdo_geometry,
member function get_latitude(
p_sequence number default 1 ) return number,
member function get_longitude(
p_sequence number default 1 ) return number,
member function get_address(
p_sequence number default 1 ) return varchar2,
member function get_street(
p_sequence number default 1 ) return varchar2,
member function get_city(
p_sequence number default 1 ) return varchar2,
member function get_state(
p_sequence number default 1 ) return varchar2,
member function get_zipcode(
p_sequence number default 1 ) return varchar2,
member function get_county(
p_sequence number default 1 ) return varchar2,
member function get_country(
p_sequence number default 1 ) return varchar2
);
The object’s body is a bit long and I will not post all of it here but will make it all available for download. But I will post a few of the member functions and talk about what they are doing.
constructor function google_geocode_type( p_search varchar2 default null ) return self as result is begin self.search := p_search; return; end;
For those who are not familiar with PL/SQL object types, a constructor function is the method called when you create a new instance of the object (just like java). Every object has a default constructor, but you can define your own so to manage the object’s creation as well as defaulting certain object attributes. For me, I did not want the use to have to supply a value for the attribute RESPONSE so I defined my own.
The EXECUTE() method is very similar to the the prior example. I made a minor change to handle the case where we get back more than 32K of data.
member procedure execute( p_search varchar2 default null ) is
l_http_req utl_http.req;
l_http_resp utl_http.resp;
l_response long;
l_clob clob;
begin
if p_search is not null then
self.search := p_search;
end if;
l_http_req := utl_http.begin_request(
url => 'http://maps.google.com/maps/geo' ||
'?q=' || utl_url.escape( self.search ) || -- address to geocode
'&output=xml' || -- XML return type
'&key=abcdef' ); -- site key
l_http_resp := utl_http.get_response( l_http_req );
begin
loop
utl_http.read_text( l_http_resp, l_response );
l_clob := l_clob || l_response;
end loop;
exception
when utl_http.end_of_body then
null;
end;
utl_http.end_response( l_http_resp );
self.response := sys.xmlType.createXML( l_clob );
end execute;
Now depending on how specific the address you supply, you may get more than one answer. I sent in a value of “1600 Pennsylvania Ave” and it returned 10 results. If I made that search more specific, say “1600 Pennsylvania Ave, DC”, then I get just a single result. But since we don’t know how many results we will get, we need to parse out all the results. So the first thing we need to know is how many results came back.
member function get_result_count return number is
l_count number;
begin
select count(*)
into l_count
from table( XMLSequence( extract(
self.response,
'//Placemark',
'xmlns="http://earth.google.com/kml/2.0"' ) ) );
return l_count;
end get_result_count;
This method calculates how many results are in the XML returned by finding each <Placemark> section, and then counting them using the XMLSequence and Table functions in SQL.
Now we know how many results, we can begin to ask for the individual values.
member function get_zipcode(
p_sequence number default 1 ) return varchar2 is
begin
return self.response.extract(
'//Placemark[@id="p' || p_sequence || '"]',
'xmlns="http://earth.google.com/kml/2.0"' ).extract(
'//PostalCodeNumber/text()',
'xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"' ).getStringVal();
end get_zipcode;
Here in the GET_ZIPCODE() method, we use the EXTRACT() method on the XMLType variable RESPONSE and XPATH searching to retrieve the proper zipcode. I had to do and extract() of an extract() because the relavant peices of data were in different namespaces in the XML. (My XPATH searching ability is not that strong so there may be an easier way? If you know of one, let me know.)
All the other get methods are similiar to this example.
Now let’s see how we would use this.
1 declare 2 g google_geocode_type := new google_geocode_type(); 3 begin 4 g.execute( '1910 Oracle way, reston' ); 5 dbms_output.put_line( 'lat/lon: ' || 6 g.get_latitude()||'/'|| 7 g.get_longitude() ); 8 dbms_output.put_line( 'Address: ' || g.get_address() ); 9 dbms_output.put_line( 'County: ' || g.get_county() ); 10* end; SQL> / lat/lon: -77.351976/38.954872 Address: 1910 Oracle Way, Reston, VA 20190, USA County: Fairfax County PL/SQL procedure successfully completed.
Given just the street and the city, google was able to determine the full address and the latitude and longitude.
Now let’s see what happens when we supply even less information
1 declare 2 g google_geocode_type := new google_geocode_type(); 3 begin 4 g.execute( '1600 Pennsylvania Ave' ); 5 for i in 1 .. g.get_result_count() loop 6 dbms_output.put_line( 'lat/lon: ' || 7 g.get_latitude(i)||'/'|| 8 g.get_longitude(i) ); 9 dbms_output.put_line( 'Address: ' || g.get_address(i) ); 10 end loop; 11* end; SQL> / lat/lon: -90.229033/38.617594 Address: 1600 Pennsylvania Ave, St Louis, MO 63104, USA lat/lon: -76.880242/42.031789 Address: 1600 Pennsylvania Ave, Pine City, NY 14871, USA lat/lon: -82.984848/42.36331 Address: 1600 Pennsylvania St, Detroit, MI 48214, USA lat/lon: -76.634388/39.30307 Address: 1600 Pennsylvania Ave, Baltimore, MD 21217, USA lat/lon: -96.77534/32.759033 Address: 1600 Pennsylvania Ave, Dallas, TX 75215, USA lat/lon: -81.620803/38.360844 Address: 1600 Pennsylvania Ave, Charleston, WV 25302, USA lat/lon: -80.27183/40.687529 Address: 1600 Pennsylvania Ave, Monaca, PA 15061, USA lat/lon: -79.8573/40.362383 Address: 1600 Pennsylvania Ave, West Mifflin, PA 15122, USA lat/lon: -117.32709/34.084866 Address: 1600 Pennsylvania Ave, Colton, CA 92324, USA lat/lon: -75.185584/40.121061 Address: 1600 Pennsylvania Ave, Oreland, PA 19075, USA PL/SQL procedure successfully completed.
There sure are a lot of 1600 Pennsylvania Ave’s. But if you notice, the most famous one is not even in the list? Why? I have NO idea??? But if we make our search a bit more specific…
1 declare 2 g google_geocode_type := new google_geocode_type(); 3 begin 4 g.execute( '1600 Pennsylvania Ave, dc' ); 5 for i in 1 .. g.get_result_count() loop 6 dbms_output.put_line( 'lat/lon: ' || 7 g.get_latitude(i)||'/'|| 8 g.get_longitude(i) ); 9 dbms_output.put_line( 'Address: ' || g.get_address(i) ); 10 end loop; 11* end; SQL> / lat/lon: -77.036698/38.897102 Address: 1600 Pennsylvania Ave NW, Washington, DC 20006, USA PL/SQL procedure successfully completed.
… we find that famous one that will be getting a new family moving in this January.
I hope this was interesting and helpful. Again, if you want to get the code and try it out yourself, its right here. And as always, if you have any questions, just ask.
Quick Geocoding Using Google
Location based services are all the rage these days. Everyone is including it into their applications and there are many ways to accomplish this. Oracle supports geocoding in the database but you need to own the geocoding dataset. To get that dataset, you would probably need to purchase it from some provider like NAVTEQ.
But there are services out there, like Google, that allows us common folk to use its data, but you have to know how to ask for it. Google offers a ton of Javascript APIs for mapping and geocoding, but that does nothing for us working in the database with PL/SQL. I routinely want to geocode the addresses in a table on insert and update via a trigger. Javascript is not going to help you here.
Luckily, Google supports geocoding via HTTP and I have written a simple function to access it. ( Oracle also supports a geocoding solution via HTTP and has a hosted site to support it. I will blog about it in the future. )
create or replace
function google_geocode( p_address varchar2 ) return sdo_geometry is
l_http_req utl_http.req;
l_http_resp utl_http.resp;
l_response long;
l_latlon long;
begin
l_http_req := utl_http.begin_request(
url => 'http://maps.google.com/maps/geo' ||
'?q=' || utl_url.escape( p_address ) || -- address to geocode
'&output=csv' || -- simplest return type
'&key=abcdef' ); -- Google API site key
l_http_resp := utl_http.get_response( l_http_req );
utl_http.read_text( l_http_resp, l_response );
utl_http.end_response( l_http_resp );
l_latlon := substr( l_response, instr( l_response, ',', 1, 2 ) + 1 );
return sdo_geometry(
2001, 8307,
sdo_point_type( to_number( substr( l_latlon, instr( l_latlon, ',' )+1 )),
to_number( substr( l_latlon, 1, instr( l_latlon, ',' )-1 )),
null ),
null, null );
end google_geocode;
That’s it. It’s not that complicated. You just need to send via HTTP the address and you will get back a comma separated string which we parse out the latitude and longitude and stuff into a sdo_geometry type.
I’ll quickly dissect the code.
Line 9 – Initializing the HTTP call. The URL includes 3 parameters ( q, output and key )
- q is the address string to be geocoded.
- output is the format that we want the out returned in. I chose csv. It’s the simplest for this example.
- key is the your Google API key. ( Read more about getting a Google API key ).
Lines 15-17 – Sending the request and fetching the result via HTTP. The result that the comes back is in the form of:
- HTTP_return_code,accuracy,latitude,longitude
Line 18 – Substring the latitude and longitude.
Line 20 – Creating and returning the SDO_GEOMETRY
Now you can call this from your pl/sql code in the database, or code in your ApEx app ( since that too is stored and run in the database ) and geocode any address. Just like this:
SQL> select google_geocode( '1910 Oracle Way, Reston' ) g 2 from dual; G(SDO_GTYPE, SDO_SRID, SDO_POINT(X, Y, Z), SDO_ELEM_INFO, SDO_ORDINATES) -------------------------------------------------------------------------------- SDO_GEOMETRY(2001, 8307, SDO_POINT_TYPE(-77.351976, 38.954872, NULL), NULL, NULL)
I tried to set up a quick demo of this on apex.oracle.com here, but I need to get the access to run UTL_HTTP via setting up an ACL. I am trying to see if I can get the admins to allow that for me.
If you want to read more about the options Google offers for geocoding via HTTP, you can read about it here.
As always, if you have any questions, just ask.
Christopher Beck's Blog 