Let’s assume you have the following table:

CREATE TABLE dept(
  DeptNo INT(10),
  DName VARCHAR(14),
  loc VARCHAR(13),
  Salsum FLOAT
);

Let’s execute the following query in the SQL document:

SELECT DName, loc FROM dept WHERE DeptNo = 20;

Now if you change any of the values of the first record in Data Editor, the changes will be applied to all records of the original table that have ‘DName’ = ‘Research’ and ‘loc’ = ‘Dallas’.

It happens because when dbForge Studio for MySQL generates the internal UPDATE statement, only the fields returned by the previous query are included in the WHERE clause of the UPDATE statement. In our example DeptNo = 20 that was stated in the WHERE clause of the SELECT statement was not included in the internal UPDATE statement as there was no the ‘DeptNo’ field in the grid when modifying data.

So that if you’re planning to modify data that will be returned as a result of the SELECT statement in the grid, we suggest you to make sure that all the fields that are specified in the WHERE clause of the SELECT statement are also specified in the SELECT clause of the statement.

In our example, you have to specify the ‘DeptNo’ field in the SELECT clause of the statement.

SELECT DeptNo, DName, loc FROM dept WHERE DeptNo = 20;

Now if you modify any of the values of the records in Data Editor, the above actions will exclude accidental changes in the records that are not displayed in the grid.

Finally, to avoid such problems that may occur when modifying data that was returned as a result of the ‘SELECT’ statement inside of which the ‘WHERE’ clause is used, make sure you’re specifying the ‘*’ in the ‘SELECT’ clause or at least all the columns listed in the ‘WHERE’ clause of the statement.

As Christmas holidays are drawing closer, we offer you to get 20% off any product license order.

Don’t think twice, just save 20%. And what more, you get free access to all future releases of the respective products for one year.

Hurry up, this offer is available only from December 01, 2011 till January 10, 2012. Decide and order right now.

We wish you all the best in the coming year, let joy and happiness be your constant partners and friends!

Best Christmas Wishes,
Devart Team

Types of Debuggers
Now we will consider the types of debuggers that can be implemented for MySQL server and principles of their work.

The first way of debugging stored procedures is to divide their code to separate statements and send each statement separately. This way execution is being emulated, because, for example, the same cycles or branches will be executed not on the server side, but by a client itself. And this brings the accuracy of the debugger work into question.

The second way of debugging stored procedures is that additional control items are placed near every statement. And with the help of these items the procedure execution can be suspended, but in spite of all this the procedure is executed entirely on the server side.

Advantages and Shortcomings of the Debugging Methods
The first method has its advantages and shortcomings. The great advantage is that no additional code is executed at the server side and the code of the procedure is left unchanged. The shortcoming of this method is that the main amount of code is executed on the client side and not on the server side, and that is an emulation of code execution, but not code execution itself. Because of this the result returned after debugging often differs from the result returned by the server after executing the procedure. And this situation is worsened by the fact that the result of code execution can differ depending on the MySQL server version. For example, in MySQL 4.1 “NOT” and “!” operators have identical priority, but in the version 5.0 and higher the priority is different, and it is impossible to take into account all such nuances. That’s why such debugger will return the same result on different server versions, because it will not take into account all refinements of code execution on different servers, and instead will interpret the code on its own.

The advantage of the second method is that the procedure is executed on the server completely, and this guarantees 100% correct result of debugging. Client does not interpret anything and all execution process is controlled by server. That’s why problems associated with different MySQL server versions are not topical for this kind of debugger. But one should “pay” for the high quality of such debugger, because its main shortcoming is that extra operations should be performed to add control items into the procedure body, even in spite of the fact that these items can be easily added and easily deleted.

Conclusion
One should decide on his or her own what kind of debugger is better for him or her. dbForge Studio for MySQL could not allow a user to get wrong results during debugging and that’s why it chose the second method and created a server side debugger. It sacrificed the convenience to some extent, but gained a great advantage in the accuracy of the debugging results.

dbForge Studio for MySQL - Best IDE Product

Support Your Favorite Devart Products in 2011 DevProConnections Voting!

We would like to invite you to take part in 2011 DevProConnections voting. The Community Choice Awards, as presented by Windows IT Pro, SQL Server Magazine, and DevProConnections, allow you to decide, which IT products get chosen for acclaim and recognition.

This year Devart dbForge Studio for MySQL is nominated in the following category.

2011 DevProConnections Community Choice Awards:

Category 14 (page 2): Best IDE Product – dbForge Studio for MySQL

If you think that Devart’s MySQL GUI Client is worth of being the best in the given categories, vote now for your favourite Devart products:

2011 DevProConnections Community Choice Awards

With Best Wishes,
The Devart Team

Tests were run under .Net Framework 2.0 on Wine emulator.

The following command line functionality works with no visible issues:

• /backup – backups a database
• /restore – restores a database
• /datacompare – launches a data comparison
• /datacompare /sync – launches a database synchronization
• /schemacompare – launches a schema comparison
• /schemacompare /sync – launches a database synchronization
• /dataexport (starting from version 5.0) – exports data
• /dataimport (starting from version 5.0) – imports data
• /execute – executes a script

Testing of the following GUI functionality completed with full success:

• Import Wizard
• Export Wizard
• Backup Wizard
• Restore Wizard
• SQL Formatter Wizard

Data comparison. We were able to perform data comparison operation with some limitations:

• there is no possibility to view differences between the records of the relevant objects
• Data Synchronization Wizard doesn’t work at all

Schema comparison. Testing of the schema comparison functionality finished with the following results:

• Schema Comparison Wizard works properly
• Schema Synchronization Wizard is supported excepting the possibility to view synchronization script for the object. However, you can save documents and use them as a command line argument

Stored procedures debugger. Works properly if you disregard the artifacts.

The rest of the functionality is associated with tool-windows or documents and mostly blocked because of problems with rendering. To avoid the issues associated with tool-windows, change the window status from Docked to Floating and vice versa.

If you are interested in using dbForge Studio for MySql on Linux, you can use the following installation recommendations:

1. Build wine with the following options:

app-emulation/wine-1.3.3 USE="X alsa dbus gecko jpeg ncurses opengl perl png ssl threads
truetype win32 xinerama xml (-capi) -cups -custom-cflags (-esd) -fontconfig -gnutls
(-gphoto2) -gsm (-hal) -jack -lcms -ldap -mp3 -nas -openal -oss -pulseaudio -samba (-scanner)
 -test -win64 -xcomposite"

2. Install to a new folder .wine files (optionally, but preferably)

3. Run:

- sh winetricks gdiplus

Note: Do not use gdiplus from wine (dbforge crashes with an error when starting)

4. Install dotnet20 (in Fedora13 the installation interrupts with an error):

- sh winetricks dotnet20

5. Run:

wine ./dbforgemysqlru.exe (installs with no visible issues)

Funny video about history of our MySQL GUI tool

We did not intend to have a professional video made by clip-makers. The video was shot frame-by-frame using a common digital camera. After that jpg files were rendered to the mp4 video format. Shooting took almost 7 hours. All models were made by hand from plasticine by one of our employees, whose hobby is design and model-making. All of us want to thank him for this!

Now let’s analyse how one can save data from a MySQL table to a CSV file.

The first and very likely the easiest way is to change Storage Engine to CSV and save it to some archived file with such name as table_name.CSV. To do this it is necessary to execute:

ALTER TABLE table_name ENGINE=CSV;

If we execute such statement for the sakila.actor table, we will instantly get the “Cannot delete or update a parent row: a foreign key constraint.” message.
OK, let’s delete all foreign keys referencing this table and execute the DDL statement once more. Now we will get the “The used table type doesn’t support AUTO_INCREMENT columns.” message.
Let’s remove the AUTO_INCREMENT property from the actor_id column and try to execute our statement again. Now we get the “Too many keys specified; max 0 keys allowed” message.
So we should delete all indexes, unique keys, and primary keys, and only after this you get a CSV file you can work with on the server machine.
As we can see, this is not a very easy way of saving MySQL table data to the CSV format, because we had to ruin referential integrity of our database and make too many changes to the schema created in the first place. The second shortcoming is that it is impossible to save N number of rows.

The second way does not have the shortcomings listed above. To perform the requested operation, you should execute:

SELECT * INTO OUTFILE 'sakila_actor.csv' FROM sakila.actor;

But by default the field delimiter is TAB, data is saved without quoting, and information regarding date and time is saved in an unusual format. That’s why it is necessary to customize the settings in the following way:

SELECT actor_id, first_name, last_name, DATE_FORMAT(last_update,'%m/%d/%Y %H:%i:%s')
INTO OUTFILE 'sakila_actor.csv'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' LINES TERMINATED BY '\n'
FROM sakila.actor
LIMIT 10;

Excellent! Now we can save the needed fields and the needed number of table rows.
And this way also has some shortcomings. For example, it is impossible to execute this statement several times. In this case the “File ‘sakila_actor.csv’ already exists” error arises. But the common shortcoming of both these ways is that the file is always saved on the server side. Not all users that have permissions to select data have access to the file system.

We offer you a way that doesn’t have any shortcomings mentioned above.

Let’s see how easy it is just to export data from a MySQL table to the CSV format and save the resulting file locally using a dbForge Studio for MySQL.

Select the needed table in Database Explorer and select where to export data from the popup menu.

MySQL Data Export: Context Menu

After that in Data Export Wizard that appeared select the needed format – CSV.

MySQL Data Export Wizard: CSV Format

On the next page of the wizard we can set the column separator and quote string we need, but as the preset variant is suitable for us, we go to the next page of the wizard.

MySQL Data Export Wizard: Column Separator and Quote String

On the Data Format page you can set the format in which integer and float numbers, empty strings, date and time should be saved, but as the preset format is suitable for us, we go to the next page of the wizard.

MySQL Data Export Wizard: Date and Time Format

On the next page we can limit the number of exported rows and press the data export button.

MySQL Data Export Wizard: Range of Rows

OK! The data was successfully exported to a CSV file. If you want, you can save the settings specified earlier as a template and use them when exporting data from this or any other table next time.

MySQL Data Export Wizard: Export Finish and Save Template

Of course, it is not necessary to perform all these tiresome steps and it is possible to click the export button on the first page of the wizard.

Our tool supports command line in the 5 version of dbForge Studio for MySQL to save export project and to start export of data from the needed tables and in the set cyclic periods of time or in the specified time with the help of Windows Scheduler.

What do you think about the ways of data export described in this article? How do you usually export data?

Cutting-Edge MySQL GUI Client: dbForge Studio for MySQL

With the help of our users we could work on the product on the new level, and as a result of such successful tight cooperation its standard of quality grew. This new standard includes taking into account actual needs of people using our product and implementing their exact requirements except studying the market in general and implementing features that are theoretically demanded.

When you open the application to get acquainted with the new version, you will be surely stunned and pleasantly surprised by its new look. When you start using it, we hope you will be thrilled by the inner improvements and make the best use of them:

Dependencies List

First of all, test the usability of Dependencies List – a unique feature that will allow you to see the object’s references and dependants. No more need to spend precious minutes on looking all this up!

Full support for MySQL server 5.5

Master-Detail Data Browser

You are welcome to explore and analyze master-detail data in a browser with rich settings, and save your data and diagrams for future use.

Enhanced Data Editor

Foreign key lookup editor was added. Resources of client machines will be spared with server-side sorting and filtering. Data Editor now informs about its state. Capabilities to edit tables in join statements, to number records, copy data with header, and build graphical representation of data with a wizard are now available.

Improved Security Manager

Maintaining server security is one of the most responsible tasks. We did our best to make it easier by redesigning Security Manager. Now you can edit several users at once, group them by hosts, and grant definite sets of privileges with the help of virtual roles.

Data Export and Import improvements

Export data from several tables at once and save your time by exporting and importing data through the command line.

Object Viewer - a simple way to view object’s details

Object Viewer (formerly known as Summary Window) was totally redesigned to provide an easier way for analyzing objects and their structure.

Appearance improvements

Brand new start page for quick access to the most frequently used features and new skins for a better look.

Other improvements

Ability to view internal SQL queries that are sent to the server with parameter’s values added
Few UI improvements in Database Explorer were made
Options to ignore clauses during the comparison of events added to the Schema Comparison wizard
Highlighting of differences on comparing SQL profiling results added
More informative progress during Schema and Data comparison

Availability

Consumers can give the updated dbForge Studio for MySQL a test drive by downloading the free Express edition or the 30-day trial Professional edition at the product download page. dbForge Studio license price starts at $49.95.

To leave feedback, users can go to the dbForge Studio for MySQL feedback page. The Devart team is looking forward to receiving any comments and suggestions.

Downloads: http://www.devart.com/dbforge/mysql/studio/download.html

The database that MySQL server uses to store internal data about users is called mysql by default. There are tables for storing information about users’ accounts in this database:

• user contains a list of all users of the MySQL server and their permissions to access the database;
• db contains a list of databases with a matching list of database users and their privileges for executing operations;
• tables_priv contains a list of database tables (views) that a user has access to;
• columns_priv contains a list of columns from the database tables (views) a user has access to;
• procs_priv contains a list of database procedures (functions) a user has access to.

To get the list of users’ privileges concerning data access, the following queries may be executed:

• the list of global privileges:

  SELECT
  mu.host `Host`,
  mu.USER `USER`,
  REPLACE(RTRIM(CONCAT(
  IF(mu.Select_priv = 'Y', 'Select ', ''),
  IF(mu.Insert_priv = 'Y', 'Insert ', ''),
  IF(mu.Update_priv = 'Y', 'Update ', ''),
  IF(mu.Delete_priv = 'Y', 'Delete ', ''),
  IF(mu.Create_priv = 'Y', 'Create ', ''),
  IF(mu.Drop_priv = 'Y', 'Drop ', ''),
  IF(mu.Reload_priv = 'Y', 'Reload ', ''),
  IF(mu.Shutdown_priv = 'Y', 'Shutdown ', ''),
  IF(mu.Process_priv = 'Y', 'Process ', ''),
  IF(mu.File_priv = 'Y', 'File ', ''),
  IF(mu.Grant_priv = 'Y', 'Grant ', ''),
  IF(mu.References_priv = 'Y', 'References ', ''),
  IF(mu.Index_priv = 'Y', 'Index ', ''),
  IF(mu.Alter_priv = 'Y', 'Alter ', ''),
  IF(mu.Show_db_priv = 'Y', 'Show_db ', ''),
  IF(mu.Super_priv = 'Y', 'Super ', ''),
  IF(mu.Create_tmp_table_priv = 'Y', 'Create_tmp_table ', ''),
  IF(mu.Lock_tables_priv = 'Y', 'Lock_tables ', ''),
  IF(mu.Execute_priv = 'Y', 'Execute ', ''),
  IF(mu.Repl_slave_priv = 'Y', 'Repl_slave ', ''),
  IF(mu.Repl_client_priv = 'Y', 'Repl_client ', ''),
  IF(mu.Create_view_priv = 'Y', 'Create_view ', ''),
  IF(mu.Show_view_priv = 'Y', 'Show_view ', ''),
  IF(mu.Create_routine_priv = 'Y', 'Create_routine ', ''),
  IF(mu.Alter_routine_priv = 'Y', 'Alter_routine ', ''),
  IF(mu.Create_user_priv = 'Y', 'Create_user ', ''),
  IF(mu.Event_priv = 'Y', 'Event ', ''),
  IF(mu.Trigger_priv = 'Y', 'Trigger ', '')
  )), ' ', ', ') AS `Privileges`
 FROM
  mysql.USER mu
 ORDER BY
  mu.Host,
  mu.USER

• the list of privileges for a database:

 SELECT 
  md.host `Host`,
  md.USER `USER`,
  md.db `Database`,
  REPLACE(RTRIM(CONCAT(
  IF(md.Select_priv = 'Y', 'Select ', ''),
  IF(md.Insert_priv = 'Y', 'Insert ', ''),
  IF(md.Update_priv = 'Y', 'Update ', ''),
  IF(md.Delete_priv = 'Y', 'Delete ', ''),
  IF(md.Create_priv = 'Y', 'Create ', ''),
  IF(md.Drop_priv = 'Y', 'Drop ', ''),
  IF(md.Grant_priv = 'Y', 'Grant ', ''),
  IF(md.References_priv = 'Y', 'References ', ''),
  IF(md.Index_priv = 'Y', 'Index ', ''),
  IF(md.Alter_priv = 'Y', 'Alter ', ''),
  IF(md.Create_tmp_table_priv = 'Y', 'Create_tmp_table ', ''),
  IF(md.Lock_tables_priv = 'Y', 'Lock_tables ', ''),
  IF(md.Create_view_priv = 'Y', 'Create_view ', ''),
  IF(md.Show_view_priv = 'Y', 'Show_view ', ''),
  IF(md.Create_routine_priv = 'Y', 'Create_routine ', ''),
  IF(md.Alter_routine_priv = 'Y', 'Alter_routine ', ''),
  IF(md.Execute_priv = 'Y', 'Execute ', ''),
  IF(md.Event_priv = 'Y', 'Event ', ''),
  IF(md.Trigger_priv = 'Y', 'Trigger ', '')
  )), ' ', ', ') AS `Privileges`
 FROM
  mysql.db md
 ORDER BY
  md.Host,
  md.USER,
  md.Db

• the list of privileges for tables:

 SELECT 
  mt.host `Host`,
  mt.USER `USER`,
  CONCAT(mt.Db, '.', mt.Table_name) `Tables`,
  REPLACE(mt.Table_priv, ',', ', ') AS `Privileges`
 FROM
  mysql.tables_priv mt
 WHERE
  mt.Table_name IN
  (SELECT
  DISTINCT
    t.table_name `tables`
  FROM
    information_schema.tables AS t
  WHERE
    t.table_type IN
    ('BASE TABLE', 'SYSTEM VIEW', 'TEMPORARY', '') OR
    t.table_type <> 'VIEW' AND
    t.create_options IS NOT NULL
  )
 ORDER BY
  mt.Host,
  mt.USER,
  mt.Db,
  mt.Table_name;

• the list of privileges for views:

 SELECT 
  mv.host `Host`,
  mv.USER `USER`,
  CONCAT(mv.Db, '.', mv.Table_name) `Views`,
  REPLACE(mv.Table_priv, ',', ', ') AS `Privileges`
 FROM
  mysql.tables_priv mv
 WHERE
  mv.Table_name IN
  (SELECT
  DISTINCT
    v.table_name `views`
  FROM
    information_schema.views AS v
  )
 ORDER BY
  mv.Host,
  mv.USER,
  mv.Db,
  mv.Table_name;

• the list of privileges for table columns:

SELECT 
  mtc.host `Host`,
  mtc.USER `USER`,
  CONCAT(mtc.Db, '.', mtc.Table_name, '.', mtc.Column_name) `Tables Columns`,
  REPLACE(mtc.Column_priv, ',', ', ') AS `Privileges`
FROM
  mysql.columns_priv mtc
WHERE
  mtc.Table_name IN
  (SELECT
  DISTINCT
    t.table_name `tables`
  FROM
    information_schema.tables AS t
  WHERE
    t.table_type IN
    ('BASE TABLE', 'SYSTEM VIEW', 'TEMPORARY', '') OR
    t.table_type <> 'VIEW' AND
    t.create_options IS NOT NULL
  )
ORDER BY
  mtc.Host,
  mtc.USER,
  mtc.Db,
  mtc.Table_name,
  mtc.Column_name;

• the list of privileges for view columns:

 SELECT
  mvc.host `Host`,
  mvc.USER `USER`,
  CONCAT(mvc.Db, '.', mvc.Table_name, '.', mvc.Column_name) `Views Columns`,
  REPLACE(mvc.Column_priv, ',', ', ') AS `Privileges`
 FROM
  mysql.columns_priv mvc
 WHERE
  mvc.Table_name IN
  (SELECT
  DISTINCT
    v.table_name `views`
  FROM
    information_schema.views AS v
  )
 ORDER BY
  mvc.Host,
  mvc.USER,
  mvc.Db,
  mvc.Table_name,
  mvc.Column_name;

• the list of privileges for procedures:

 SELECT
  mp.host `Host`,
  mp.USER `USER`,
  CONCAT(mp.Db, '.', mp.Routine_name) `Procedures`,
  REPLACE(mp.Proc_priv, ',', ', ') AS `Privileges`
 FROM
  mysql.procs_priv mp
 WHERE
  mp.Routine_type = 'PROCEDURE'
 ORDER BY
  mp.Host,
  mp.USER,
  mp.Db,
  mp.Routine_name;

• the list of privileges for functions:

 SELECT
  mf.host `Host`,
  mf.USER `USER`,
  CONCAT(mf.Db, '.', mf.Routine_name) `Procedures`,
  REPLACE(mf.Proc_priv, ',', ', ') AS `Privileges`
 FROM
  mysql.procs_priv mf
 WHERE
  mf.Routine_type = 'FUNCTION'
 ORDER BY
  mf.Host,
  mf.USER,
  mf.Db,
  mf.Routine_name;

You may need to create a decent printable report with this data, and to give it as a report, for example, by the demand of a customer or authority. For this purpose you may use a special MySQL GUI tool that includes a data report designer.

If you have ready queries, you can make advantage of an easy-to-use wizard and create a report using a predefined template and data grouped, for example, by host, in several minutes.



New Data Report menu



Data Report Wizard



Data Report Custom Query



Data Report Load Query



Data Report Group by Host



Data Report Title



Data Report Preview

As you can see on these screenshots, we have created a report using dbForge Studio’s wizard without tedious designing the report itself.

]]> http://www.devart.com/blogs/dbforge/index.php/how-to-get-a-list-of-permissions-of-mysql-users.html/feed 0