I am very excited to announce that the the FINAL 1.5 version of
the InfiniDB Community Edition is now available for use.
Thanks to everyone in the community for helping us through the
alpha, beta, and RC cycles to the 1.5 release of InfiniDB.
We've put a lot of hard work into this release and we've come a
long way since 1.0. Here's a reminder of a few of the
features that have been added since 1.0:
High-speed subqueries.
Support for running on...
MySQL has supported prepared statements since version 5.0,
but the use of the non-prepared statement API is still much more
popular. Here, I'll explain what prepared statements are in
short, and show some examples and why you would, and would not,
use them.
The concept of a prepared statement is that it a SQL
statement that is lacking any parameters or literals and
with these being replaced by placeholders. Then the statement is
parsed and optimized without those values, and the placeholders
are referenced to program variables. Once this is done, to
execute the prepared statement, you set the program variables to
the appropriate values and then execute the statement. You may
change the program variables referencing the placeholder values
and re-execute the SQL statement as many times as you want,
without having to re-parse or optimize the statement.
The different steps then are:
This is my 2 cents in the Open Source vs. Open Code vs.
Commercial debate. And it's a long one...
Maybe some of you reading this are offended already, but bear
with me, I'll get there. The way I see the Open Source model,
having worked with OSS at MySQL for 6+ years now, is that this is
a great way of developing software. Not brilliant, but great, but
I'll get there also.
Users of OSS, in my mind, are OSS users for one or more of three
reasons:
A couple of new webinar recordings are available from our web site:
Like our live webinars, the recordings are of course free of charge. Enjoy!
…
I very much like the fact that MySQL allows you to embed comments into SQL statements. These comments are extremely convenient, because they are written into MySQL log files as part of the query. This includes the general log, the binary log and the slow query log. Maatkit includes tools which interact with these logs, including mk-query-digest. This tool, in particular, has a very nice option called --embedded-attributes which can process data embedded in query comments.
The support for embedded attributes makes some cool tricks possible. Peter and I co-presented a talk at this past MySQL Conference and Expo. In this talk I presented my Instrumentation-for-PHP class as a demonstration …
[Read more]
InnoDB uses fuzzy checkpoints. If you search, you can
find some details on this. I don't think the
behavior of it is widely understood. There are few details in
SHOW INNODB STATUS unless you use the Facebook patch and it is
easy to miss this problem.
InnoDB uses a background thread to request and perform writes for
dirty pages when there are too many dirty pages. This is done by
background threads to avoid delaying foreground threads and to
use IO capacity when a server is otherwise idle. I draw a
distinction between request and perform.
Background IO threads perform the IO operation in Linux by
calling write or pwrite. By request …
It seems like everyone in the MySQL community has been chiming in on the so-called “open core” versus Open Source debate. It seems like at least one potential opinion has been unsaid so far, and it’s the one I share: It doesn’t matter if you’re closed source, “open core”, or Open Source, as long as you are completely honest with your customers and/or your users about which of those you are, and that you communicate any changes, particularly in a more closed direction.
I think this is the problem that MySQL (regardless of owners) have suffered in the past — they faced pressure to make money (which is fine), and they decided to used closed source approaches to do so (which is fine), and they picked some features, which they’d promised their users for a long time, to do it with (which is fine, although arguably not that nice), and they failed to communicate it well to either users or customers (which is tragic). The end result …
[Read more]Chances are, if you write Java applications using MySQL’s Connector/J driver, you’ve run across the autoReconnect property. I remember that when I first found it, it seemed I had found the grail itself. “No more nasty connection closed error messages,” I thought. Except … it doesn’t really work that way, does it? I’ve seen this question asked many times in many different contexts: “Why doesn’t Connector/J just reconnect to MySQL and re-issue my statement, instead of throwing this Exception?”
There are actually a number of reasons, starting with loss of transactional integrity. The …
[Read more]When examining MySQL configuration, we quite often want to know how various buffer sizes are used. This matters because some buffers (sort_buffer_size for example) are allocated to their full size immediately as soon as they are needed, but others are effectively a "max size" and the corresponding buffers are allocated only as big as needed (key_buffer_size). There are many examples of this. What about join_buffer_size?
I saw a my.cnf with a 128M join_buffer_size the other day and needed to research this quickly before I gave advice. The join buffer is a special case. Unlike many of the buffers that are allocated per-thread (i.e. per-connection), this one is allocated per-join-per-thread, in special cases. A join buffer is allocated to cache rows from each table in a join when the join can't use an index. This is because we know that the nested loop is effectively going to do a table scan on the inner table -- it has to, because there's no …
[Read more]|
I joined the number of those who have a public opinion on the
open core debate. Roberto Galoppini has graciously accepted to host a post on this topic in his Commercial Open Source Software blog. Please read it directly from there: Open to the core - The pragmatic freedom Enjoy! |