Blog
home > blog > Formattare e indentare le query SQL

Tag: Programmazione, tip, sql

Formattare e indentare le query SQL

Programmando con editor avanzati si può sfruttare l'indentazione automatica del codice. Cosa che manca nelle interfacce per i database. Vediamo come aggirare il problema.
di Maurizio Ceravolo
I tool di programmazione più recenti sono di grande aiuto per i programmatori, tramite indentazione automatica, colorazione del codice e intellisense aiutano gli sviluppatori a rendere il proprio codice più leggibile e a scriverlo più velocemente.

La leggibilità (è una delle proprietà intrinseche di un linguaggio di programmazione) è una proprietà molto importante per il proprio codice. Un programma leggibile permette al programmatore di modificarlo e manutenerlo molto più facilmente. Essendo facile da leggere, aiuta a rendere più semplice la sua comprensione.

L'indentazione è una delle attività più importanti per rendere il codice leggibile. Si può fare in maniera manuale, oppure (meglio) in maniera automatica se l'editor che si sta usando lo supporta.

Per spiegare quanto è importante l'indentazione, penso che più di mille parole di spiegazione, sia meglio un esempio.

Vi metto di seguito una porzione della libreria jQuery scritta in Javascript.

Codice non indentato.
/*!
* jQuery JavaScript Library v1.6.2
* http://jquery.com/
*
* Copyright 2011, John Resig
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* Includes Sizzle.js
* http://sizzlejs.com/
* Copyright 2011, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
*
* Date: Thu Jun 30 14:16:56 2011 -0400
*/
(function(a,b){function cv(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||
a.parentWindow:!1}function cs(a){if(!cg[a]){var b=c.body,d=f("<"+a+">").appendTo(b),
e=d.css("display");d.remove();if(e==="none"||e===""){ch||(ch=c.createElement("iframe"),
ch.frameBorder=ch.width=ch.height=0),b.appendChild(ch);if(!ci||!ch.createElement)
ci=(ch.contentWindow||ch.contentDocument).document,
ci.write((c.compatMode==="CSS1Compat"?"<!doctype html>":"")+"<html><body>"),ci.close();
d=ci.createElement(a),ci.body.appendChild(d),e=f.css(d,"display"),b.removeChild(ch)}
cg[a]=e}return cg[a]}function cr(a,b){var c={};f.each(cm.concat.apply([],cm.slice(0,b)),
function(){c[this]=a});return c}function cq(){cn=b}function cp()
{setTimeout(cq,0);return cn=f.now()}function cf()
{try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}
Obiettivamente non si capisce niente.

Vediamo la una porzione di codice correttamente indentata.

/*!
 * jQuery JavaScript Library v1.6.2
 * http://jquery.com/
 *
 * Copyright 2011, John Resig
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * Includes Sizzle.js
 * http://sizzlejs.com/
 * Copyright 2011, The Dojo Foundation
 * Released under the MIT, BSD, and GPL Licenses.
 *
 * Date: Thu Jun 30 14:16:56 2011 -0400
 */
(function( window, undefined ) {

// Use the correct document accordingly with window argument (sandbox)
var document = window.document,
	navigator = window.navigator,
	location = window.location;
var jQuery = (function() {

// Define a local copy of jQuery
var jQuery = function( selector, context ) {
		// The jQuery object is actually just the init constructor 'enhanced'
		return new jQuery.fn.init( selector, context, rootjQuery );
	},

	// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,

	// Map over the $ in case of overwrite
	_$ = window.$,

	// A central reference to the root jQuery(document)
	rootjQuery,

	// A simple way to check for HTML strings or ID strings
	// (both of which we optimize for)
	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,

	// Check if a string has a non-whitespace character in it
	rnotwhite = /\S/,

	// Used for trimming whitespace
	trimLeft = /^\s+/,
	trimRight = /\s+$/,

	// Check for digits
	rdigit = /\d/,

	// Match a standalone tag
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,

	// JSON RegExp
	rvalidchars = /^[\],:{}\s]*$/,
	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

	// Useragent RegExp
	rwebkit = /(webkit)[ \/]([\w.]+)/,
	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
	rmsie = /(msie) ([\w.]+)/,
	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,

	// Matches dashed string for camelizing
	rdashAlpha = /-([a-z])/ig,

	// Used by jQuery.camelCase as callback to replace()
	fcamelCase = function( all, letter ) {
		return letter.toUpperCase();
	},

	// Keep a UserAgent string for use with jQuery.browser
	userAgent = navigator.userAgent,

	// For matching the engine and version of the browser
	browserMatch,

	// The deferred used on DOM ready
	readyList,

	// The ready event handler
	DOMContentLoaded,

	// Save a reference to some core methods
	toString = Object.prototype.toString,
	hasOwn = Object.prototype.hasOwnProperty,
	push = Array.prototype.push,
	slice = Array.prototype.slice,
	trim = String.prototype.trim,
	indexOf = Array.prototype.indexOf,

	// [[Class]] -> type pairs
	class2type = {};

jQuery.fn = jQuery.prototype = {
	constructor: jQuery,
	init: function( selector, context, rootjQuery ) {
		var match, elem, ret, doc;

		// Handle $(""), $(null), or $(undefined)
		if ( !selector ) {
			return this;
		}

		// Handle $(DOMElement)
		if ( selector.nodeType ) {
			this.context = this[0] = selector;
			this.length = 1;
			return this;
		}

		// The body element only exists once, optimize finding it
		if ( selector === "body" && !context && document.body ) {
			this.context = document;
			this[0] = document.body;
			this.selector = selector;
			this.length = 1;
			return this;
		}

		// Handle HTML strings
		if ( typeof selector === "string" ) {
			// Are we dealing with HTML string or an ID?
			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
				// Assume that strings that start and end with <> are HTML and skip the regex check
				match = [ null, selector, null ];

			} else {
				match = quickExpr.exec( selector );
			}

			// Verify a match, and that no context was specified for #id
			if ( match && (match[1] || !context) ) {

				// HANDLE: $(html) -> $(array)
				if ( match[1] ) {
					context = context instanceof jQuery ? context[0] : context;
					doc = (context ? context.ownerDocument || context : document);

					// If a single string is passed in and it's a single tag
					// just do a createElement and skip the rest
					ret = rsingleTag.exec( selector );

					if ( ret ) {
						if ( jQuery.isPlainObject( context ) ) {
							selector = [ document.createElement( ret[1] ) ];
							jQuery.fn.attr.call( selector, context, true );

						} else {
							selector = [ doc.createElement( ret[1] ) ];
						}

					} else {
						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
					}

					return jQuery.merge( this, selector );

				// HANDLE: $("#id")
				} else {
					elem = document.getElementById( match[2] );

					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentNode ) {
						// Handle the case where IE and Opera return items
						// by name instead of ID
						if ( elem.id !== match[2] ) {
							return rootjQuery.find( selector );
						}

						// Otherwise, we inject the element directly into the jQuery object
						this.length = 1;
						this[0] = elem;
					}

					this.context = document;
					this.selector = selector;
					return this;
				}

			// HANDLE: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return (context || rootjQuery).find( selector );

			// HANDLE: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}

		// HANDLE: $(function)
		// Shortcut for document ready
		} else if ( jQuery.isFunction( selector ) ) {
			return rootjQuery.ready( selector );
		}

		if (selector.selector !== undefined) {
			this.selector = selector.selector;
			this.context = selector.context;
		}

		return jQuery.makeArray( selector, this );
	},

	// Start with an empty selector
	selector: "",

	// The current version of jQuery being used
	jquery: "1.6.2",

	// The default length of a jQuery object is 0
	length: 0,

	// The number of elements contained in the matched element set
	size: function() {
		return this.length;
	},

	toArray: function() {
		return slice.call( this, 0 );
	},

	// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get: function( num ) {
		return num == null ?

			// Return a 'clean' array
			this.toArray() :

			// Return just the object
			( num < 0 ? this[ this.length + num ] : this[ num ] );
	},

	// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems, name, selector ) {
		// Build a new jQuery matched element set
		var ret = this.constructor();

		if ( jQuery.isArray( elems ) ) {
			push.apply( ret, elems );

		} else {
			jQuery.merge( ret, elems );
		}

		// Add the old object onto the stack (as a reference)
		ret.prevObject = this;

		ret.context = this.context;

		if ( name === "find" ) {
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
		} else if ( name ) {
			ret.selector = this.selector + "." + name + "(" + selector + ")";
		}

		// Return the newly-formed element set
		return ret;
	},

	// Execute a callback for every element in the matched set.
	// (You can seed the arguments with an array of args, but this is
	// only used internally.)
	each: function( callback, args ) {
		return jQuery.each( this, callback, args );
	},

	ready: function( fn ) {
		// Attach the listeners
		jQuery.bindReady();

		// Add the callback
		readyList.done( fn );

		return this;
	},

	eq: function( i ) {
		return i === -1 ?
			this.slice( i ) :
			this.slice( i, +i + 1 );
	},

	first: function() {
		return this.eq( 0 );
	},

	last: function() {
		return this.eq( -1 );
	},

	slice: function() {
		return this.pushStack( slice.apply( this, arguments ),
			"slice", slice.call(arguments).join(",") );
	},

	map: function( callback ) {
		return this.pushStack( jQuery.map(this, function( elem, i ) {
			return callback.call( elem, i, elem );
		}));
	},

	end: function() {
		return this.prevObject || this.constructor(null);
	},

	// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: push,
	sort: [].sort,
	splice: [].splice
};
Ovviamente qui il codice è molto più facile da leggere, con una istruzione per riga e l'indentazione che permette di capire dove ci sono cicli e biforcazioni del codice.

È indubbiamente un grosso vantaggio. Soprattutto averlo automaticamente.

Funzione che purtroppo manca sugli editor di SQL, il linguaggio di interrogazione dei database. Sinceramente è una cosa che non ho mai capito. Quando si lavora in SQL, occorre indentare a mano.

Cosa che rende più difficoltosa la scrittura di query complesse.

In questi casi io mi aiuto con due comodissimi servizi on line.

Il primo è INSTANT SQL FORMATTER. Si presenta con una interfaccia molto semplice e facile. Una grande TextArea dove copiare l'SQL che vogliamo indentare, ed una serie di campi che ci permettono di scegliere alcune opzioni fra cui la scelta del DBMS (SQL Server, MySql, Oracle, ....) che si sta usando. Qui potete vedere un esempio del funzionamento.

Il secondo è T-SQL Beautifier. Questo servizio è più orientato all'SQL di Microsoft SQL Server. L'interfaccia è ancora più semplice e permette di scegliere solo fra alcune combinazioni di opzioni già fatte. Anche qui possiamo vedere un esempio. In più offre anche T-SQL Analyzer, che permette di analizzare l'SQL che stiamo sottoponendo e restituisce un report con dei consigli su come renderlo più efficiente e prestazionale.

Consiglio vivamente di usarli quando state scrivendo query molto complesse.

Happy coding. :-)
Post correlati
2010
9
Dicembre
TSQL: concatenare più record senza usare un cursore
Maurizio Ceravolo
Concatenare più record di una tabella in un'unica stringa necessita un cursore, che però è poco performante. Vediamo un metodo tramite FOR XML PATH per concatenare con una query secca.
2011
19
Aprile
Cambiare l'indirizzo del proprio sito senza penalizzare il pagerank
Maurizio Ceravolo
Quando si decide di spostare il proprio sito ad un altro indirizzo occorre fare alcune operazioni per non perdere il pagerank guadagnato con tanto lavoro.
2011
30
Maggio
CSS: ridimensionare le immagini proporzionalmente
Maurizio Ceravolo
Vediamo una semplice tecnica per ridimensionare le immagini senza che perdano la proporzione usando i css, e farli sempre entrare nel layout che abbiamo creato.
2011
18
Aprile
AlgoRythmics: gli algoritmi di ordinamento spiegati con la danza
Maurizio Ceravolo
Un'idea molto originale di una università romena. Spiegare gli algoritmi di ordinamento (Shell Sort, Selection Sort, Insertion Sort, Bubble Sort) tramite la danza.
2010
5
Novembre
Ebook gratuito sulla programmazione Windows Phone 7
Maurizio Ceravolo
Il blog di Microsoft Press mette a disposizione un ebook gratuito sulla programmazione del nuovo sistema operativo mobile di casa Microsoft.


Archivio Mensile Blog
Tag Cloud
Apple comunicazione Dualboot Facebook geek Google Google+ HTC humor innovazione iPad iPhone marketing Microsoft mobile social network utility video videogiochi Windows Phone
Ultimi Post
I migliori di oggi
I più popolari del mese
Top post