http://www.mysqlperformanceblog.com/2010/01/07/star-schema-bechmark-infobright-infinidb-and-luciddb/

http://www.mysqlperformanceblog.com/2009/10/02/analyzing-air-traffic-performance-with-infobright-and-monetdb/

http://www.mysqlperformanceblog.com/2009/10/26/air-traffic-queries-in-luciddb/

http://www.mysqlperformanceblog.com/2009/11/02/air-traffic-queries-in-infinidb-early-alpha/

).
However benchmarks by itself did not cover all cases I would want, so I was thinking about better scenario. The biggest problem is to get real big enough dataset, and I thank to Bradley C. Kuszmaul, he pointed me on Wikipedia statistics on access to wikipedia pages, and thank to Domas, who made stats accessible. Link to the archives: http://dammit.lt/wikistats/archive/ or the original Domas’s announcement .
Although the table does not have very much different information, I think it is good enough to represent cases you can face in Web application ( log processing, page visits, clickstream, etc).
I made some efforts to normalize data to have model in classic star schema and prepared queries that could be run on proposed dataset (John Sichi, lead of LucidDB helped me to draft some queries).
You can see details on our Percona Wikistat benchmark Wiki.
I have next goals with proposed benchmark:

Compare engines in OLAP queries for planning, predicting growth, analyzing access patterns to wiki pages, draw trends.
Compare engines in statistical queries for end users, which can be executed in real-time. I.e. How many times that or another page was accessed yesterday vs today.
Understand specific features and characteristic of each engine.
Compare throughput on simple queries (queries and scenario to be drafted yet)
Check ability to load data and serve queries at the same time ( availability during data load ) (queries and scenario to be drafted yet)

So in proposed schema I have four tables:
pagestat (fact table), and pages, datesinfo, projects (dimensions tables).
Dimensions tables are supposed to be static and not changed, and we can change datasize
by varying amount of months loaded into fact table (so this is scale factor).
EEM diagram

( made with MySQL Workbench )
In current dataset, which you can download from Amazon snapshot (name: ?percona-wikistat?, ID:snap-a5f9bacc) we have:

Table pages: 724.550.811 rows. data size: 40476M
Table datesinfo: 9624 rows, one entry represents 1 hour
Table projects: 2025 rows
Table pagestats
Data for 2009-06: # 3.453.013.109 rows / size 68352M
Data for 2009-07: # 3.442.375.618 rows / szie 68152M

So with two months of stats we have about 172GB of data with about 7 billion rows in fact table.
Example of query ( again, full list on Benchmark Wiki)
PLAIN TEXT
SQL:

SELECT project, sum#40;page_count#41; sm

nbsp;FROM pagestat

nbsp; nbsp;JOIN datesinfo di ON #40; di.id=date_id #41;

nbsp; nbsp;JOIN projects p ONnbsp; #40;p.id=project_id #41;

nbsp;WHERE di.calmonth=7 AND di.calyear=2009

nbsp;GROUP BY project

nbsp;ORDER BY sm DESC

nbsp;LIMIT 20;

I am going to load data and run queries against available engines:

MySQL MyISAM / InnoDB (to have reference results)
InfoBright
InfiniDB
MonetDB
LucidDB
Greenplum

and I will report my results ( so stay with MySQLPerformanceBlog )
I’d like also to test also Paraccel, Vertica and KickFire systems, but I do not have access to.
I welcome your feedback on the benchmark, and what else you would like to see here.

Data Modeling
Query (upgrade from MySQL Query Browser)
Admin (upgrade from MySQL Administrator)

If you are a current user of MySQL Query Browser or MySQL Administrator, we look forward to your feedback on all the new capabilities we are delivering in a single unified MySQL Workbench
As always, you will find binaries for the various platforms on our download pages.
Please get your copy from our Download

http://dev.mysql.com/downloads/workbench/

To get started quickly, please take a look at this short tutorial.
MySQL Workbench 5.2 Beta Tutorial

http://wb.mysql.com/?p=406

Please be aware that this release is still a beta version ? so please don?t use it on your production servers! Also note, MySQL Workbench files saved with version 5.2 cannot be opened with previous versions of our program.
The files for several platforms have been pushed to our main server and should be available on our mirrors.
Blog postings and general information ? including build instructions for Linux ? can be found on our Workbench Developer Central site.
Workbench Developer Central

http://wb.mysql.com

Workbench Documentation and details on changes between releases can be found on these pages

http://dev.mysql.com/doc/workbench/en/index.html

http://dev.mysql.com/doc/workbench/en/wb-change-history.html

Pada episode OpenScreen kali ini saya membahas tentang cara menginstall MySQL di Linux secara manual. Jadi tidak menggunakan apt-get atau yum secara otomatis, sehingga kita menginstall benar-benar secara manual tanpa bantuan sistem operasi linux.

Untuk lebih jelas silahkan download video tutorialnya disini :

http://tiny.cc/xfJle

Link-link terkait :

http://www.mysql.com/

http://www.linuxmint.com/

http://www.ubuntu.com/

Dikutip dari : http://openscreen.wordpress.com

Unfortunately my internet line died over the weekend, and I was left without a connection until Tuesday. I had a bit of offline time to have a look at some interesting new(ish) technology.

If you have paid any attention to Gnome development, there are mentions of gnome-shell, and something about making it easier to develop add-on/applets etc. using Javascript. I have not really had time to look at this much, however given the fact I had downloaded all the components prior to my loss of connectivity, I spent some time over the weekend and monday looking at this in more detail.

It looks like there are obviously things going on in IRC and mailing lists, so most of my impressions are from the websites, and code. There are basically 2 projects currently.

GJS – This is the mozilla Javascript engine bound to the gobject introspection system
Seed – This is the webkit Javascript engine bound to the gobject introspection system

Of the two, Seed apears to be a little more advanced and more time has gone into it, based on the fact there appear to be more core features in Seed (eg. I could not find anything like Seed.print() in GJS), and there are very few examples in GJS

Both of these use the GObject introspection method to bind to Gtk, and a large and growing number of other libraries. This is something I found very interesting having gone through a similar process with rooscript.

The fundimental issue of creating bindings to Gtk (and anything that uses the GObject system) is that historically, almost everyone (PHP, Python etc.) who did it used this method.

* Parse the html documentation, or the .h files (extracting the classes, enums, methods, arguments etc.)
* Generate Binding code for each library, which wraps these methods, loads the ‘.so’ libraries and links it all together.
* Compile a Module (or statically link it in some cases)
* Run… Test.. Fix bugs in wrapping code… Run … Test.

What GObject inspection introduces is an very thin layer that can be used to expose any of these methods without writing any binding code (other than to GObject inspection). The result is that to add more features (linking to another library) – you just have to generate a XML file describing the interface, compile it with g-ir-compile and put it in the right folder, and you have magically added support to a new Library, without generating an C code!

This also means that fixing the binding is considerably simpler (fix the XML file, re-compile etc.) and you have solved bugs in any language that is using it… (as I found with gtk_tree_store_set_column_types()

Playing with the languages.

GJS and Seed present the Gtk API very slightly differently, which at present appears to be a bit of a blocker for deciding which to use (or even to bother for some). The key differences are for authoring

* Javascript ‘let’ features in GJS – not available in Seed.. – This is rather a big blocker as code designed for GJS will fail in Seed totally.. (and visa-versa probably)
* Different call signatures to signalsÃ? Ã? Ã?  SEED:OBJECT.signal.connect(method)Ã?  vsÃ?  GJS:OBJECT.connect(’signal’, method)Ã?  – I think personally that GJS way is more true to the concept and cleaner, however as you can see below there are ways around this.

Seed has a git repo on gnome ’seed-examples’, which contains a large number of examples, although their depth is rather thin unfortunatly.. (code coverage is probably 1% at best)…
Both have pretty much Zero in the documentation stakes.. – A rather trivial task to create – which I’m tempted to have a go at….

Anyway back to my playing around..

I’ve been doing some serious shit in Javascript recently, GUI builders, Code generators, Hacking GTK bindings etc. so I’ve seen the good, bad and ugly as far as Javascript goes (Bad sometimes being my code).Ã?  I’ve been slowly moving to what I regard as an effecient, productive use of Javascript, most of which can be seen in the xtype support in RooJS

After runing the first few examples in seed-examples, I decided to see if using an xtype / Roo structure could be done with Seed. After a bit of tweaking, and bugfixing of Seed, I finally got this code to work.

var win = XN.xnew({
    xtype : Gtk.Window,
    type: Gtk.WindowType.TOPLEVEL,
    listeners : {
        'delete-event' : function (widget, event) {
            return false;
        },
        destroy  : function (widget) {
            Gtk.main_quit();
        }
   },

   set : {
        set_border_width : [ 10 ],
        resize : [300, 300],
        show_all : []
   },
   items : [