SQL Server requires that each variable and column in a table should be defined with respect to the type of data it will store. From a bit to a huge image and binary storage types, the allocation is supposed to help the user conform to the data required, and help the engine allocate space and processing speed efficiently.

Built-in data types

SQL Server 2000 recognizes the following built in data types:

bigint
Integer data from -2^63 through 2^63-1

int
Integer data from -2^31 through 2^31 – 1

smallint
Integer data from -2^15 through 2^15 – 1

tinyint
Integer data from 0 through 255

bit
Integer data with either a 1 or 0 value

decimal
Fixed precision and scale numeric data from -10^38 +1 through 10^38 -1

numeric
Fixed precision and scale numeric data from -10^38 +1 through 10^38 -1

money
Monetary data values from -2^63 through 2^63 – 1

smallmoney
Monetary data values from -214,748.3648 through +214,748.3647

float
Floating precision number data from -1.79E + 308 through 1.79E + 308

real
Floating precision number data from -3.40E + 38 through 3.40E + 38

datetime
Date and time data from January 1, 1753, through December 31, 9999, with an accuracy of 3.33 milliseconds

smalldatetime
Date and time data from January 1, 1900, through June 6, 2079, with an accuracy of one minute

char
Fixed-length character data with a maximum length of 8,000 characters

varchar
Variable-length data with a maximum of 8,000 characters

text
Variable-length data with a maximum length of 2^31 – 1 characters

nchar
Fixed-length Unicode data with a maximum length of 4,000 characters

nvarchar
Variable-length Unicode data with a maximum length of 4,000 characters

ntext
Variable-length Unicode data with a maximum length of 2^30 – 1 characters

binary
Fixed-length binary data with a maximum length of 8,000 bytes

varbinary
Variable-length binary data with a maximum length of 8,000 bytes

image
Variable-length binary data with a maximum length of 2^31 – 1 bytes

cursor
A reference to a cursor

sql_variant
A data type that stores values of various data types, except text, ntext, timestamp, and sql_variant

table
A special data type used to store a result set for later processing

timestamp
A database-wide unique number that gets updated every time a row gets updated

uniqueidentifier
A globally unique identifier

How to choose the appropriate data type

SQL Server stores data in data pages that are 8Kb (8192 bytes) in size. The system uses some of that s Sometimes, the system uses only 8060 bytes are availableto that are available to store user’s data. Consider the size of a row of data in your tables. If the rows are large, make sure that multiples of the fit conveniently on a data page so that page space is not wasted. This is cut down on disk paging overhead when accessing the data. You want to maximize the number of rows of data which that will fit on a page. This can be accomplished both by splitting the tables, and by choosing the smallest data type which that will accommodate your data. .

If you are using integer data, data; consider that the tinyint datatype will accommodate data which that will fit into one byte of storage. So if the range of all of the data in your field (or variable) is between 0 and 255, use the tinyint datatype. If the range is between -32,768 and 32,767, use the smallint data type. And if If you need to store integer data from -2,147,483,648 through 2,147,483,647, use int data type.

Similarly with smallmoney. If smallmoney. if your value range is between -214748.3648 and 214,748.3647, use the smallmoney datatype.

Use smalldatetime data type instead of datetime data type, if you need to store the date and time data from January 1, 1900 through June 6, 2079, with accuracy to the minute.

Prefer varchar.nvarchar to text/ntext whenever possible because the text and image fields are stored separately, which produces additional paging. And prefer char/varchar to nchar/nvarchar data types because the n types require twice as much storage space. The n types are used primarily for unicode data.

The following is a reference to the main math functions in SQL:

ABS(X) Absolute value-converts negative numbers to positive, or leaves positive numbers alone
CEIL(X) X is a decimal value that will be rounded up.
FLOOR(X) X is a decimal value that will be rounded down.
GREATEST(X,Y) Returns the largest of the two values.
LEAST(X,Y) Returns the smallest of the two values.
MOD(X,Y) Returns the remainder of X / Y.
POWER(X,Y) Returns X to the power of Y.
ROUND(X,Y) Rounds X to Y decimal places. If Y is omitted, X is rounded to the nearest integer.
SIGN(X) Returns a minus if X < 0, else a plus.
SQRT(X) Returns the square root of X.

Q: What is normalization?

A: Normalization is a technique of database design that minimizes the amount of redundancy in the database tables. This is accomplished by laying out tables (mainly columns and key fields) in a manner that reduces the amount of duplicate data being stored in the tables. When people talk about normalization, you will hear them talk about forms. This article will talk about the first 3 forms. To learn more about forms and database design practices the following books are great references Database Design for Mere Mortals or Beginning Database Design.

First Normal Form
This form refers to classifying data into seperate tables where that data in each table is of similar type and giving each table a primary key.

Second Normal Form
This form involves removing to other tables data that is only dependent on a part of the key. As with the definition of database normalization, you are trying to reduce redundancy. Here is an example: If you have two tables – authors and books, you do not want to put the author’s address in both tables. If you need the author’s address in the books table, you would only put a reference to the primary key for the author from the Authors table in the Books table. This way, you will be able to use all of the information about the author without having to maintain it in more than one place.

Third Normal Form
This form involves getting rid of anything in the tables that does not depend solely on the primary key. Only include information that is dependent on the key and move off data to other tables that are independent on the primary key and create primary key for the new tables.

Normalization is crucial to good database design, but it is not necessary to normalize all of the way to the third or fourth form for every database that you create. Use common sense and use the amount of normalization that the situation calls for and the amount that you feel comfortable with.

sp_columns table name

The reason for having a database is to have vast amounts of data organized and readily available. SQL is the means by which we can communicate with the database and tell it to find exactly what we need. From thousands of records, we can filter it down to precisely what we are searching for, granted if the database schema was created efficiently.

Let’s look at an example, using the HAVING clause. Let’s say we wanted to search for all employees who have an average salary of $50,000.

*Note, when using HAVING you always have to incorporate GROUP BY filtering.

Here’s how we would do it.

SELECT employee, AVG(salary)
FROM employee_data
GROUP BY employee
HAVING AVG(salary) > 50000;

See how used the AVG aggragate function to get the average salaray?

You can also find this information using the WHERE clause.

We have previously found the minimum and maximum range for a price column in a table.

But what if we wanted to find the values in between? Say for example you wanted to view all the products you sell between $50 and $100 dollars?

SELECT * FROM products WHERE price BETWEEN 50 AND 100;

See how easy that is, it almost reads like a normal sentence, this is why SQL is considered to have natural language syntax.

Now, the between operator can also be used to find in a range of letters.

For example, if we have a table of employees and a column with employee last names, and we wanted to find all the employees whose last names range from a-m, we would do a query like this:

SELECT * FROM employees WHERE lastname BETWEEN a AND m;

Easy as pie.

When running more complex queries, such as concatenating strings, often times you may need to trim whitespace from the values.

Let’s look at an example of this. Remember the query we ran for concatenating:

SELECT CONCAT (productName, ” , ” , price) FROM products;

As it is the output would be XBOX , $399

Let’s say we wanted to trim the whitespace between XBOX and the comma.

Here’s the query:

SELECT CONCAT (RTRIM(productName) ” , ” , price) FROM products;

In this case we used rtrim because we wanted to trim to the right or immediately following the value. If we wanted to trim space before the value we would use the LTRIM, and if we wanted to trim from both sides, we would simply use trim.

Aggregate means a whole, the term is most used in economics (if you have ever taken an economics class, you probably remember how painful it was ), it basically means ‘as a whole’. So, we’ll cover a few simple aggregate functions , avg,max, and min.

Remember the price we concatenated with a string? What if we wanted to see the average price of all our the products in our products table?

SELECT AVG(price) AS average_price FROM products;

the query would return something along the lines of 23.94443, obviously depending the prices in your table , if it were cars, it might be 23,232.2238576.

Notice we also used an alias in there.

Now , what if we wanted to find the minimum and maximum price in our products table?

SELECT MIN(price) AS mini_price, MAX(price) AS max_price FROM products;

The output should be two numbers let’s say : $3.99 $599.99

That’s it, aggregate functions are often overlooked as an easy way to get quick info.

A word of warning about concatenating with sql, if the data used is one that is created by a user where query strings are created dynamically, there could be a possibility of an sql injection. This method is best used for outputting information you have in a database. For example, let’s say you have a products table and you want to concatenate the product name and price.

SELECT CONCAT (productName, ” , ” , price) FROM products;

The output would be: XBOX, $399

You can see the power in this function. We could just as well add some text modifiers:

SELECT CONCAT (productName, ” , “”Buy it Now,” , price) FROM products;

The output would be: XBOX, Buy it Now, $399

The Concat operator is used mainly by mysql. Other database engines such as Oracle use the “||” operator.

SQL Joins, or joining of database tables is one the most difficult for noobs to understand, but this is one of the more powerful queries out there. Yeah, its nice and comfy when you have just one table and everything is right there. But there will be times, many actually, when your databases will hold various tables that you have to bring together in order to retrieve query results.

Let’s take an example of a two table database where one table is for colleges and the other is for states.

SELECT DISTINCT
c.id,c.name
FROM colleges as c
INNER JOIN state AS s
ON s.college_id = c.id
WHERE id = ” id ” ;

Okay, obviously I need to explain a few things first. For Example, what is c.name ? Up until now we had been calling columns by their name. But what happens when you get to Joins is that sometimes the table and column name start getting long and before you know it the query starts reading longer Tolstoy’s war and peace.

So, taking it peace by peace:

SELECT DISTINCT (this helps to reduce any duplicates that could be in your DB)
c.id,c.name
FROM colleges as c (here we’re choosing the column’s id and name from the colleges table and giving them the alias of c (for colleges)
INNER JOIN (this is what is going to join the two tables)
state AS s (assigning the table to s)
ON (here’s the comparison, or with)
s.college_id = c.id (this says where the table holding ‘state’ and college_id should equal the table ‘college’ id
WHERE id=’id’ (this is the final refinement that gets all matches of id of this state has id of these colleges)