Agora mãos a obra …

Hoje iremos falar sobre CTE – Common Table Expression X SelfJoin.

O CTE é um recurso desde o SQL Server 2005. Se compararmos o código do Self-Join com o CTE , até parece complicado (Rs), mas ao decorrer do Post, veremos que fácil.

Antes de mais nada, Self Join é quando utilizamos a mesma tabela no FROM e no JOIN. É normal fazermos isso quando queremos por exemplo listar todos os funcionários e seus superiores. Antes do SQL Server 2005, esta era a forma que conseguíamos fazer esta junção.

SELECT E.EmployeeKey,
	   e.FirstName + '' + E.LastName as 'Employee Name',
	   ds.FirstName + '' + ds.LastName as 'Supervisor Name'
 FROM DimEmployee e
INNER JOIN DimEmployee ds ON e.ParentEmployeeKey = ds.EmployeeKey
ORDER BY e.EmployeeKey

Com esta query consigo pegar os funcionários e quem é seu supervisor.

Ao decorrer do Post, iremos ver várias maneiras da utilização do CTE. Lembrando que podemos utilizar no escopo de SELECT, INSERT, DELETE, MERGE ou DELETE.

Uma CTE pode se auto referenciar (CTE recursiva) e pode ser referenciada várias vezes na mesma query.

Sintaxe:

WITH expression_name [ ( column_name [,...n] ) ]
AS
( CTE_query_definition )

Vou dar um exemplo simples da utilização:

WITH CTE_Simples (Id, Nome) AS
(
     SELECT Id, Nome FROM Funcionario
)
SELECT * FROM CTE_Simples

ou até mesmo

WITH CTE_Simples (Id, Nome) AS
(
     SELECT 1, 'Rafaela'
)
SELECT * FROM CTE_Simples

Simples não é mesmo ??? Claro, quando pensamos na utilização do CTE, pensamos em recursividade. Onde eu preciso chamar a minha CTE várias vezes, e isso cai no caso do exemplo que dei sobre Self-Join.

Vamos então utilizar o exemplo do Self-Join utilizando CTE.

Para trabalhar com CTE recursiva (Recursive CTE), tem uma query inicial, chamada de query âncora e uma segunda query que é liga a âncora, através do UNION ALL.

WITH Employee_CTE (employeeKey,Level, EmployeeName) AS
(
	SELECT e.EmployeeKey, 1, e.FirstName + '' + E.LastName as Name
 	FROM DimEmployee e
	WHERE e.ParentEmployeeKey IS NULL
	UNION ALL
	SELECT e.EmployeeKey, cte.level + 1, e.FirstName + ' ' + E.LastName AS Name
	FROM DimEmployee e
	INNER JOIN Employee_CTE cte ON E.ParentEmployeeKey  = cte.employeeKey
)
SELECT * FROM Employee_CTE

Se executarmos as duas querys (Self-Join e CTE) o Execute Plan tratá os seguintes custos:

• Self-Join – 0.0642
• CTE – 0.0249.

Claro, temos que considerar que a tabela que estou utilizando tem apenas 296, mas a intensão é mostrar que temos um ganho de performance utilizando o CTE.

Bom espero que tenham gostado, e nos vemos na próxima.

Além disso, podemos compilar e executar código representado por árvores de expressão, isso permite a modificação dinâmica de código executável.

A ilustração a seguir mostra um exemplo de uma expressão e sua representação:

Na prática

public static void Main(string[] args)
{
    //Criando a seguinte Expression Tree Lambda Expression:
    //num => num < 5
    //
    //Não esqueça de importar o namespace: System.Linq.Expressions
    ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
        ConstantExpression five = Expression.Constant(5, typeof(int));
            BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
            Expression<Func<int, bool>> lambda1 =
                Expression.Lambda<Func<int, bool>>(
                    numLessThanFive,
                    new ParameterExpression[] { numParam });
}

Sub Main()
    'Criando a seguinte Expression Tree Lambda Expression:
    'num => num < 5
    '
    'Não esqueça de importar o namespace: System.Linq.Expressions
    Dim numParam As ParameterExpression = Expressions.Expression.Parameter(GetType(Integer), "num")
    Dim five As ConstantExpression = Expressions.Expression.Constant(5, GetType(Integer))
    Dim numLessThanFive As BinaryExpression = Expressions.Expression.LessThan(numParam, five)
    Dim lambda1 As Expression(Of Func(Of Integer, Boolean)) = _
                                 Expressions.Expression.Lambda(Of Func(Of Integer, Boolean)) _
                                 (numLessThanFive, _
                                 New ParameterExpression() {numParam})
End Sub

T+

As Expressões Lambda usam o operador =>. O lado esquerdo do operador Lambda especifica os parâmetros de entrada e o lado direito especifica a expressão. Por exemplo, a Expressão Lambda: x => x * x.

Regras para utilização:

• O lambda deve conter o mesmo número de parâmetros como o tipo de delegate;
• Cada parâmetro de entrada na lambda deve ser implicitamente convertível para o parâmetro delegate correspondente;
• O valor de retorno do lambda (se houver) deve ser implicitamente conversível no tipo de retorno do delegate.

Na prática

• Exemplo 1

delegate void TestDelegate(string s);

TestDelegate exemplo = n => { string s = n + " " + "World"; Console.WriteLine(s); };
exemplo("Hello");

• Exemplo 2

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

int oddNumbers = numbers.Count(n => n % 2 == 1);

Abraços

• Generics
• Tipos Nulos ou Nullable Types
• Delegate Action
• Delegate Predicate
• Delegate Comparison
• Delegate Converter
• Type Inference
• Anonymous Types
• Object Initialization
• Extension Methods 

Bom, na parte do Generics ficou faltando falar sobre Constraints em Generics onde podemos definir certas restrições ao tipo T atribuído na declaração de uma classe Genérica. Podemos definir Constraints para os seguintes casos:

• Deve ser um tipo por valor;
• Deve ser um tipo por referência;
• Deve ter um construtor sem parâmetro (parameter less);
• Deve ser especificada uma determinada classe ou sub-classe;
• Deve ser implementada uma determinada interface.

Definindo Constraints

Na prática

public class Cliente<T>
	where T : IDisposable, new()
{
       //Implementar a classe
}

Public Class Cliente(Of T As {IDisposable, New})
       'Implementar a classe
End Class

Por enquanto é só!!! Até o próximo post.

• VB.NET
  • Devem obrigatoriamente ser definidos dentro de um módulo com o atributo ExtensionAttribute que fica localizado dentro do namespace System.Runtime.CompilerServices (System.Core.dll).
• C#.NET
  • Devem obrigatoriamente ser definidos dentro de uma classe estática e não precisa de nenhum atributo definido;
  • O tipo a estender é antecedido pela keyword this para indicar ao compilador que o método deve ser adicionado aos métodos do tipo Extension Methods.

Na prática

		public static class Helper
		{
			public static bool IsValidEmail(this string value)
			{
				System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$");
				return regex.IsMatch(value);
			}
		}

		public static void Main(string[] args)
		{
			string email = "vrevers@dominio.com.br";
			Console.WriteLine(email.IsValidEmail());
		}
	

		<System.Runtime.CompilerServices.Extension()> _
		Public Function IsValidEmail(ByVal value As String) As Boolean
			Dim regex As New System.Text.RegularExpressions.Regex("[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$")
			Return regex.IsMatch(value)
		End Function

		Sub Main()
			Dim email As String = "vrevers@dominio.com.br"
			Console.WriteLine(email.IsValidEmail())
		End Sub
	

Espero que tenham gostado!!!

Na prática

	public class Pessoa
	{
		public String Nome { get; set; }
		public String Apelido { get; set; }
	}

	public static void Main(string[] args)
	{
		Pessoa pessoa = new Pessoa() { Nome = "Ovidio", Apelido = "DVD"};
	}
	

	Public Class Pessoa

		Private _nome As String
		Private _apelido As String

		Public Property Nome() As String
			Get
				Return _nome
			End Get
			Set(ByVal value As String)
				_nome = value
			End Set
		End Property

		Public Property Apelido() As String
			Get
				Return _apelido
			End Get
			Set(ByVal value As String)
				_apelido = value
			End Set
		End Property

	End Class

	Sub Main()
		Dim pessoa As New Pessoa With {.Nome = "Ovidio", .Apelido = "DVD"}
	End Sub
	

Na prática

public static void Main(string[] args)
{
	var pessoa = new {Nome = "Ovidio", Apelido = "DVD"};
	Console.WriteLine(pessoa.Apelido);
}

Sub Main()
	Dim pessoa = New With {.Nome = "Ovidio", .Apelido = "DVD"}
	Console.WriteLine(pessoa.Apelido)
End Sub

T+

Primeiro: Definindo o Doctype

Encontramos sites que no topo do seu código fonte ainda esta sem a definição do Doctype. Exemplo:

<html>
<head>
<title>Nome do site</title>
</head>

…

Qual linha esta faltando neste código? Algo assim:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<title>Nome do site</title>
</head>
<boby>

O que é um Doctype?

O Doctype é a Declaração do Tipo de Documento ou simplesmente DTD, todo documento (X)HTML deve conter um Doctype logo em seu inicio.

Sem esta linha o navegador o intepretará sua página usando “quirks mode” ocasionando erros no layout.

Lista de Doctypes corretos mais usados:

HTML 4.01 Strict:<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01//EN”

“http://www.w3.org/TR/html4/strict.dtd”>

HMTL 4.01 Transitional:

<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”

“http://www.w3.org/TR/html4/loose.dtd”>

XHTML 1.0 Strict:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>

XHTML 1.0 Transitional:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

Deixei o frameset de fora de propósito por ser raramente usado atualmente.

Segundo: usar reset CSS

O objetivo do “reset css” é reduzir as inconsistências dos navegadores zerando os elementos do HTML. Cada navegador tem uma forma de definir a altura, margens dos principais elementos HTML. Este recurso faz com que seu código seja melhor padronizado para depois ser interpretado suas demais formatações. Vale a pena para desenvolvedores que querem fazer sites CSS Cross-browser.

Há varios deles prontos na web. Um exemplo super básico:

* {
    padding: 0;
    margin: 0;
    border: 0;
}

Após experimentarmos alguns dos mais famosos entre eles do Yahoo, Eric Meyer, temos juntado o que vimos ser relevante:

body, div, dl, dt, dd, ul, ol, li, h1, h2, h3, h4, h5, h6, pre, code, form, fieldset, legend, input, textarea, p, blockquote, th, td {
	margin:0;
	padding:0;
}
table {
	border-collapse:collapse;
	border-spacing:0;
}
fieldset, img {
	border:0;
}
address, caption, cite, code, dfn, em, strong, th, var {
	font-style:normal;
	font-weight:normal;
}
li {
	list-style:none;
}
caption, th {
	text-align:left;
}
h1, h2, h3, h4, h5, h6 {
	font-size:100%;
	font-weight:normal;
}
q:before, q:after {
	content:'';
}
abbr, acronym {
	border:0;
	font-variant:normal;
}
/* to preserve line-height and selector appearance */
sup {
	vertical-align:text-top;
}
sub {
	vertical-align:text-bottom;
}
input, textarea, select {
	font-family:inherit;
	font-size:inherit;
	font-weight:inherit;
}
/*to enable resizing for IE*/
input, textarea, select {
*font-size:100%;
}
/*because legend doesn't inherit in IE */
legend {
	color:#000;
}
del, ins {
	text-decoration:none;
}
body {
	font:13px/1.231 arial, helvetica, clean, sans-serif;
 *font-size:small;
 *font:x-small;
}
select, input, button, textarea {
	font:99% arial, helvetica, clean, sans-serif;
}
table {
	font-size:inherit;
	font:100%;
}
pre, code, kbd, samp, tt {
	font-family:monospace;
 *font-size:108%;
	line-height:100%;
}
h1 {
	font-size:138.5%;
}
h2 {
	font-size:123.1%;
}
h3 {
	font-size:108%;
}
h1, h2, h3 {
	margin:0.5em 0;
}
h1, h2, h3, h4, h5, h6, strong {
	font-weight:bold;
}
abbr, acronym {
	border-bottom:1px dotted #000;
	cursor:help;
}
em {
	font-style:italic;
}
del {
	text-decoration:line-through;
}
blockquote, ol, dl {
	margin:1em;
}

ul{
	margin-top:0.5em;
	margin-left:0.5em;
	margin-bottom:0.5em;
}

input[type=text], input[type=password], textarea {
	width:12.25em;
*width:11.9em;
}
q {
	quotes: "" "";
}
ul, ol {
	list-style: none;
}
hr {
	display: none;
} /* we don't need a visual hr in layout */
font {
	color: inherit !important;
	font: inherit !important;
	color: inherit !important;
} /* disables some nasty font attributes in standard browsers */
marquee {
	overflow: inherit !important;
	-moz-binding: none;
}
blink {
	text-decoration: none;
}
nobr {
	white-space: normal;
}