Techwave 2008 - It's all good baby!!
You know it's a good sign when the food starts tasting much better :) That is how I compare year after year. For some reason, I personally felt a lot of energy and optimism from attendees and had great traffic at my booth. More than that, there were many great questions from the folks attending the conference, which is always good.
I managed to stay reasonably busy in the SUP booth with good traffic although there was a lack of chairs. We were positioned next to the various techathlon events that were being held and I managed to show off my non-existent footie skills.
I'm excited getting closer to release date for SUP. It's been an excellent group effort to get it out considering we had teams in Paris, Pune, Singapore, Shanghai, Xian, Dublin, London, etc. Hardest was coordinating conference calls within the teams. Techwave gave me a chance to start putting the message out with real demos and there were some good questions about the product that we've also been thinking about and it validated some of our future direction. The developer tools message was well received by the audience and they felt that would simplify their development efforts a lot.
And I did have some fun too. WHIVSIV :)
Was'SUP : The tooling story - Visual Studio or Eclipse; your choice, we support!!
Once upon a time the developers kingdom got split into two provinces, Visual Studio (Windows Platform) and Eclipse (Windows and every other platform) based on various factors like corporate IT decisions, deployment environment, language familiarity, etc. There were some other splinter provinces like (Netbeans, etc.) which continued to have a decent community but not large enough to cause any trouble.
(More...)
Was'SUP - No, I'm not that cool, it's still geek speak!!
You are going to hear a lot of this feeble attempt at humor from the resident geeks at Techwave (I guess we can exclude the marketing folks as they are pretty cool). If you have been attending the past few years of Techwave or visited Sybase home page or may be have attended any one of the presentations over the last few years, there has been a lot of chatter about Unwired Enterprise Platform.
(More...)
Eclipse Ganymede is Released Into the Wild!
Hi all...
It should be common knowledge, but Eclipse Ganymede (also known as Eclipse 3.4) is being release today! As said by the Eclipse folks (thanks Ian for writing a great press release as always) - "The Ganymede Release is a coordinated release of 23 different Eclipse project teams and represents over 18 million lines of code." It's an enormous undertaking by a diverse group of people, projects, and companies, so kudos to everyone involved!
Along with Ganymede is the next major release of DTP (version 1.6). With this release, we add some new functionality and streamline some of what was already there...
One of the things that people have asked for over the last few releases has been a graphical SQL query editor. And it's finally there! Yay!
There is still a bunch of work left to do with it, but for a first release I think it works great. I'm not a big fan of hand-coding joins in SQL statements and this makes it VERY easy to do that. Just click an drag!
Beyond that, we did a ton of work on usability in DTP 1.6 also. We've streamlined the process for creating driver definitions and connection profiles to the point where it only takes a few clicks before you're connecting to and drilling into the Data Source Explorer to view your databases. So a big thank you goes out to Max at JBoss and the Zend folks and everyone else who provided valuable feedback during our prototyping and implementation of these changes.
It's been a heck of a year, but I think DTP is better and stronger than ever. We will get started shortly on our first maintenance release (1.6.1, due out in September) and planning for the next major Eclipse release (in June 2009).
As always, we depend on the community for support and guidance going forward. As you start to explore our Ganymede release, keep an eye to the future and let us know what you'd like to see us do by next June!
Thanks to everyone involved in the DTP 1.6 release -- from Sybase, Actuate, IBM, JBoss, Zend, Ingres, and all those who I can't remember at the moment. Everyone take a bow as the curtain drops on Ganymede, enjoy a brief rest, and then it'll be time to get going again!
--Fitz
So how do you add your own custom driver template?
Hi all...
Sorry there's been a bit of a lag between articles. We've been busy trying to get Ganymede out the door and start planning for the future (maintenance releases for 1.6 plus the next major release of DTP for next June). I need to ditch my crystal ball for a magic eight ball I think. :)
Anyway... This week we're going to chat about how to create a new custom driver template.
First of all, when would you want to do this? There are a few possibilities:
1) You're creating support for a new database type not currently covered by DTP Enablement.
2) You want to add support for a third-party driver (such as DataDirect or jTDS) for a currently supported database.
3) You simply want to add an alternative driver template to complement an existing driver that adds properties or changes default values for use in your application(s).
That said, let's pick #1. We can use it as an example to provide functionality through this article series and eventually add some new database support to DTP Enablement.
For this example, let's work on SQLite support.
You can find a ton of information about SQLite on the SQLite home page ( http://www.sqlite.org/). And you can grab the SQLite JDBC driver from the SQLiteJDBC page ( http://www.zentus.com/sqlitejdbc/). So we'll grab the SQLite binaries for Windows (in my case) and the sqlitejdbc-v051-bin.tgz for this case. (You'll need to put the sqlitejdbc.dll in your JRE's or SDK's JRE bin directory to get this working.)
Typically the process I work through when deciding whether or not we need a custom connection profile for a given database is as follows:
1) Can I create a new Generic JDBC driver definition that references the jar (sqlitejdbc-v051-native.jar in this case)? Yes.
2) Can I then create a new Generic JDBC connection profile that uses my driver definition from (1) to connect to the database? Yes.
3) Can I browse into the database to see schemas, tables, stored procedures, and the like? Unfortunately not in this case.
This means we need to go a step further and go through these stages:
Stage 1: Create a new Database Definition for our Database
Stage 2: Create a new Driver Template for our Database (and the associated UI)
Stage 3: Create a new Connection Profile for our Database
Stage 4: Create a Custom Catalog Loader for our Database
So let's start with Stage 1 and get Stage 2 started today...
For each database that is supported in DTP and presents its structure in the Data Source Explorer (DSE), we have to tell the base models what the database supports. This is represented by the Database Definition (or "DB Definition"). What data types does it handle? Does it handle aliases or triggers? What kinds of constraints?
The DB Definition file itself is simply an XMI file (an XML file that provides metadata for some other XML files). In this case, it maps back to an EMF model for the DB Definition.
Basically we need to create an XMI file to tell DTP what basic properties this database adheres to. What data types does it support, does it have catalogs, and so on. Most of this information can be found in the database documentation.
To simplify the process a little, we have a sample Java file that can be customized to create a new XMI file. I've modified it somewhat to create the XMI file locally. And I'll post a zip with the necessary files on the DTP website so you can grab them at the end of this exercise.
Once that's created, you can create a plug-in wrapper called "org.eclipse.datatools.enablement.sqlite.dbdefinition". And in that plug-in wrapper we will use the org.eclipse.datatools.connectivity.sqm.core.databaseDefinition extension point to tell DTP about it. Basically the databaseDefinition extension point just maps the XMI file to a named vendor and a named version. That's how the underlying systems will locate it. (You'll see the terms vendor and version appear later as we define our driver template as well.)
So now we have a DB Definition and a plug-in wrapper for it. Cool. Now we can move to the first part of Stage 2: Creating a driver template.
To create a new driver template, we'll start by creating another plug-in. This plug-in will house all the non-UI bits and pieces we want for our SQLite connection profile. We'll call it "org.eclipse.datatools.enablement.sqlite".
In the manifest for our new SQLite plug-in, we will create a new org.eclipse.datatools.connectivity.driverExtension extension. This extension point is used to register driver template categories and driver templates within the DTP framework.
Remember how we were talking about vendor and version earlier? Well, now we're going to map some driver template categories to them.
First we'll create a "SQLite" category, which maps back to the vendor name we chose earlier and has org.eclipse.datatools.connectivity.db.driverCategory as a parent. All database drivers fall under this category in DTP so we can easily find them. We'll call our new category "SQLite" and give it an ID "org.eclipse.datatools.enablement.sqlite.driver.category".
Next, we'll create a "3.5.9" category, to map to the version we selected earlier (3.5.9 is the most recent version of SQLite I could find). This one will use our "SQLite" category as its parent. We'll call it "3.5.9", and give it an ID "org.eclipse.datatools.enablement.sqlite.3_5_9.category"
Lastly we'll create the driver template itself. We'll give it the name "SQLite JDBC Driver" (not very original, but easy to remember) and an ID "org.eclipse.datatools.enablement.sqlite.3_5_9.driver". We'll set it to our SQLite 3.5.9 parent category so it has some context, setting it to the category ID we made a second ago "org.eclipse.datatools.enablement.sqlite.3_5_9.category".
We know it needs a driver jar, so we'll provide a default jar name as "sqlitejdbc-v051-native.jar". If we get fancy later, we can provide some mechanisms to pre-populate the path to the local version of that jar, but for now we'll assume the user will be able to know where their jar is located and set it appropriately in the driver definition. (Yes, we'll talk about the "fancier" way to do this automatically later.)
Beyond that, we need to get a few key bits of information about the driver. Based on the documentation for SQLite, it appears that we require the following property values:
* Driver Class: org.sqlite.JDBC
* JDBC URL: jdbc:sqlite:test.db
Easy enough, right? Well, we also require a few other things for a standard driver definition:
* Vendor: SQLite
* Version: 3.5.9
* Database name: TEST (we can extrapolate this from the sample URL)
* User ID: (not applicable, so we just leave it blank)
With these basic bits and pieces, we have defined our driver template! Whew. Took a bit of work though, I know.
That said, we now have reusable bits we can take into the next part of this process, which is creating a connection profile that can use our new driver definition and driver template.
At this point we're just laying the ground work.
So next time we'll look at creating a basic connection profile that can actually use these bits!
You can find a zip file with some of the bits developed in this article here.
--Fitz
TechWave Registration is now open!
Join us Aug. 4 – 8 at the Mandalay Bay Resort & Casino in Las Vegas, NV... for the 10th Annual Sybase User Training and Solutions Conference.
(More...)
Enabling command-line applications for your Eclipse projects
Hi all...
Recently in DTP we came across an opportunity to provide admin-level support for some import/export type functionality within Connectivity. And it was discussed that this would be best done as a command-line application, since administrators may not have access to or wish to use the full blown Eclipse UI to handle this task.
So we started doing some digging and discovered that there's this very cool framework within the Eclipse platform to handle just this kind of thing. A bit of Googling turned up this presentation from EclipseCon 2006:
Though the Eclipse platform has changed a bit since Jeffrey wrote his article, it got me going the right direction. So I thought we'd update it for Eclipse 3.3.2.
Here's the steps we did to create this sample project...
1) Create a new plug-in project.
2) Make sure to un-check the "This plug-in will make contributions to the UI" checkbox.
3) Uncheck any available plug-in templates.
And voila, you have a new plug-in.
4) Go to the Extensions tab of the Plug-in/Manifest Editor. Add a new Extension. Select the "org.eclipse.core.runtime.applications" extension point. Click Finish when you're done.
You have a new "application" node beneath your org.eclipse.core.runtime.application extension.
5) Select the actual extension point node in the tree and note the ID of the application. This is important (I learned this the hard way). You want to provide something unique here that's not too long. It gets prefaced by the ID of your plug-in when you try to run it later.
It defaults to "idX". Call it whatever you want. In this case, we'll call it "CoolApp". The full ID is then my.cool.application.CoolApp when we go to run this later.
6) Go back to the "application" node, right-click and click New->Run. This adds the node that specifies the class you're going to run in command-line mode when you invoke your plug-in application.
7) Click the class* link to create the application class. Our application class will implement the org.eclipse.equinox.app.IApplication interface. Give it a name ("CoolApplication" in our case) and click Finish.
So you end up with the beginnings of your application class:
8) In our case, we're just testing out this functionality, so we don't have to get too fancy. In the Start method, you get an IApplicationContext object, which gives you a whole lot of information about the command line parms that were passed in.
So we're going to add some code to check out those command line parms and just write them out intelligbly.
public Object start(IApplicationContext context) throws Exception {
// get the arguments
Map args = context.getArguments();
if (args.isEmpty()) {
// if there were no arguments, simply write "hello cool world"
System.out.println("hello cool world...");
} else {
// otherwise iterate through the arguments and print them as
// "key = value" pairs after "hello cool world"
Iterator iter = args.keySet().iterator();
while (iter.hasNext()) {
Object key = iter.next();
String output = new String();
if (key instanceof String) {
output = output + (String) key + "=";
}
Object value = args.get(key);
if (value instanceof String) {
output = output + (String) value;
}
System.out.println("hello cool world, " + output);
}
}
// And now we can attempt to get some input and respond from stdio
BufferedReader stdin = new BufferedReader
(new InputStreamReader(System.in));
String message; // Creates a variable called message for input
System.out.print ("Enter the message : ");
System.out.flush(); // empties buffer, before text is input
message = stdin.readLine();
System.out.print("You ");
System.out.println("entered : " + message);
// make sure to return an OK message
return EXIT_OK;
}
So now we save our class, make sure everything compiles and builds.
9) Then we export it as a deployable plug-in.
Pick the directory where you want the jarred plug-in to be written to. In my case, I want it to be installed directly in my Eclipse plug-ins directory (the "plugins" directory is added after the directory you specify as the destination). If you put the exported plugin somewhere else, you'll have to copy it into your Eclipse/plugins directory manually. Click Finish and it will put the plug-in where you specified.
10) Now head out to a console window. Assuming you have your Java environment set up correctly, all you should have to do to run the application is go to your Eclipse directory and type:
eclipsec -nosplash -application my.cool.application.CoolApp
And that's all there is to it! I know we're going to look into using this sort of application in the future to provide some command-line import/export functionality when we get a chance.
Hope this helped you out. The Eclipse Platform has lots of cool bits that most of us User Interface people never see!
Until next time... Keep on programming!
--Fitz
Hi there...
Hi there...
This blog is a small window into some of the things going on related to the Data Tools Platform (DTP) project at Eclipse. I've been involved with DTP since it began and actually wrote some of the code that made it into the very first release. Since then, I've become more and more involved, to the point where I recently became the PMC Lead for DTP as well as the Connectivity sub-project team lead. (Yes, I wear many hats like many of the folks in the Eclipse community.)
I hope to be able to write about cool things going on in the DTP community as well as provide some code examples, samples, and commentary on open source in general.
So welcome to my little part of the blogosphere!
--Brian Fitzpatrick (aka Fitz)
Sybase at EclipseCon this week
Sybase is one of the silver sponsors for EclipseCon2008. Some of us will be at the sybase booth. Note that the exhibit hall pass is free and you can sign up online. DTP and Sybase are going to be represented in various talks and tutorials. Please stop by if you've any DTP/Sybase questions. You may also want to stay for one of the evenings as most of the evenings there is a party sponsored by one of the companies. Stop by at the booth if you just want to find out which is the cool party ..) Tutorials - Implement Schema Editing Based on Delta DDL (Dafan Yang, Sybase) - Data Applications in Eclipse: The Eclipse Data Tools Platform (Sheila Sholars, Loic Jullien, IBM; John Graham, Sybase) - Enabling support for a new database or data source in Eclipse (Philippe Ombredanne, EasyEclipse/nexB) Long Talks - Introducing DTP Open Data Access Framework (Linda Chan, Actuate) - Introducing the DTP SQL Query Builder (Brian Payton, IBM) Short talks - Creating Windows Mobile Database Applications with Eclipse (Jose Ramos, Sybase) - Push for Usability of Data Tools Wizards (Brian Fitzpatrick, Sybase) - DTP Help-Helper Plug-in (John Graham, Sybase)
TechWave 2008 Call for Papers... Now open
We are now accepting speaker proposals for the 60 and 90 sessions at the upcoming Sybase TechWave conference August 4 - 8th 2008.
(More...)
| 
