Ok, let us pretend that you have gotten the task of creating a PL/SQL package that is going to be used by your whole team. How would you comment the code you are putting together? Or, would you care about commenting at all…?

“Well, my code looks pretty good, and I don’t feel I really need to comment anything”. Let me tell you something, from my own experience: If you are getting “old” (well 46 at least) like me, and you did something about six months ago, and you have done hundreds of little things between then and now….you would wish you had some comments. That is exactly why I try to comment a lot in my code, so that I can get up-to-speed as fast as possible, if I am asked to run something I did a long time ago.

Introduction

I classify comments in five different categories:

Before I go on, you might already know, but just in case you do not – there are two ways to comment in PL/SQL:

--	This is a comment, on one line

/*	This is a multi-line comment,
	and it can just go on, and on
    ...even on multiple line.
*/

The one-line comment comments everything on one line, that comes after the double hyphens.  The multi-line comment, comments everything between the start of the comment (“/*“), and the end of the comment (“*/“). I have to admit that I sometimes use the multi-line version, even if the comment is only on one line. And, sometimes you are actually forced to if i.e. your comment is in the middle area of your line.

Ok, let’s move on.

Object header comments

This is a comment that describes the object that the code is for. The object could be a stored procedure or function. It could also be a package in PL/SQL, and so on. Here is a sample of how I do my object header comments:

CREATE OR REPLACE PACKAGE otuts_lib IS

    ------------------------------------------------------------------------------------------
    --	Name				:	otlib.sql
    --  Script/package name	: 	otuts_lib
    --	Author				:	TJ Abrahamsen
    --	Copyright			:	OracleTuts	
    --	
    --	Project				:	OTUTS library
    --	Purpose				:	Library package of OracleTuts' common utilities
    --	
    -- 	WHEN		WHO			WHAT		
    -- 	-----------	--------	-------------------------------------------------------
    -- 	5/6/2007	TEAB		Created		
    ------------------------------------------------------------------------------------------

There are a couple of things to remark, when it comes to this kind of comments:

1. Placement in file: If you always keep your latest code in a file, you might feel that the most logical placement for this kind of comment is in the top of your file. It would to me. Just remember, if you are working with a package, your code is stored in two parts: PACKAGE and PACKAGE BODY. When you compile your file, and look at your package code, you will find your header comments in the PACKAGE part, and not in the PACKAGE BODY PART. You will do most of your work in the PACKAGE BODY. Just something to consider.
2. Placement inside code block: If you look at the sample above, you will see that I have put the commented lines below the start of the PACKAGE block. If you code in your file all the time, and then compile it…any comments above the start of the block will disappear when you compile your file. So, it will not be seen when you look at your code using your favorite PL/SQL editor (like TOAD, PL/SQL Developer, Oracle SQL Developer, etc).

My recommendation is to describe the content in the object (procedure, function, package, etc.)  as well as possible. At least you should have a WHEN, WHO, and WHAT section in your header comment.

I am fully aware of that things might be a little bit changed today, since we have so many ways to store our files…like in so many different types of repositories. We can i.e. use SubVersion, or maybe a company based GIT repository. Then we can comment every time we do a “commit” of changes to the repository, and even see a log of comments between versions…and even do a diff between two file versions.

Call me old-fashioned, but I actually like to see the comments in the file itself so that I can see the reasons for the different changes there.

PROCEDURE and FUNCTION header comments

Here I am not speaking about single stored procedures or functions, but rather the different functions and procedures within a package. OR, for procedures or functions you choose to put inside your stored procedure or function.

The purpose of this type of comments would be to describe the usage of this procedure, it’s parameters, etc.

Here is a sample:

    /*	*****************************************************************************************
    	Obcject:	printAlign
        Type:		procedure
        Purpose:	This procedure is a wrapper procedure for dbms_output.put_line, and prints out
        			a variable with a set of fill characters, either on the left or right side of
                    the variable.

		PARAMETERS:	                    
    		pName:			Name of variable to print out
            pValue:			Value of the the variable to print out
            pMaxLength:		Max length of the whole print string, including two first parameters, 
            				as well as extra formatting characters
            pFillChar:		Character to be filled into "empty spaces"
            pShowLength:	Variable saying if we want to show the length of the variable value 
            				or not
    ***************************************************************************************** */

    PROCEDURE printAlign(	pName IN VARCHAR2,
    						pValue IN VARCHAR2,
                        	pMaxLength IN NUMBER,
                        	pFillChar IN VARCHAR2 DEFAULT '-',
                        	pShowLength IN BOOLEAN DEFAULT FALSE)
    IS
    	vPrintString	VARCHAR2(200);
    BEGIN
    	vPrintString := '[' || RPAD(pName || ']', pMaxLength + 3, pFillChar) || '>{' || pValue || '}';

        IF (pShowLength) THEN
        	vPrintString := vPrintString || '(.' || TO_CHAR(LENGTH(pValue)) || '.)';
        END IF;

		dbms_output.put_line(vPrintString);
    END printAlign;

The above is just an example. I usually do not use this type of comments very much. I prefer in-line commenting.

In-line commenting

This is the type of comments I definitely do most of. What I am speaking about here are comments that you can find anywhere in the code, and the main purpose is to help the reader of the code to understand some logic, the reason for calling a procedure, etc.

I classify these types of comments into:

Declaration comments

These are comments where I want to group different types of declarations in my code. They are found towards the top in my PL/SQL packages. Here are some samples:

CREATE OR REPLACE PACKAGE BODY otuts_lib IS

	----------------------------------------------------------------------------
	--  Private variables
	----------------------------------------------------------------------------

	tToken_tab	typToken_tab;
    nPos		NUMBER;

	----------------------------------------------------------------------------
	--  Private procedures/functions
	----------------------------------------------------------------------------

	FUNCTION ....
        ...
    ...

	PROCEDURE ....
        ...
    ...

	----------------------------------------------------------------------------
	--  Private procedures/functions
	----------------------------------------------------------------------------

	FUNCTION strTokenListCre(pLine IN VARCHAR2, pDelimiter IN VARCHAR2) RETURN typToken_tab IS
		sLine	VARCHAR2(2000);
    	nPos	INTEGER;
    	nPosOld	INTEGER;

Code-helping comments

The main purpose of these types of comments is to help the reader of the code to understand what is going on. I usually try to group my code into logical groups, like shown below:

CREATE OR REPLACE PACKAGE BODY xxxx IS

	...

	PROCEDURE gen_customer_stats( xxx) IS
    BEGIN

		--	----------------------------------------------
		--	Generate current week data
		--	----------------------------------------------

        /* ENROLLMENT */
        < some code >

        /* COMMISSION */
        < some code >

        /* SALES */
        < some code >

		--	----------------------------------------------
		--	Generate previous weeks data
		--	----------------------------------------------

        /* ENROLLMENT */
        < some code >

        /* COMMISSION */
        < some code >

        /* SALES */
        < some code >

    END gen_customer_stats;

	...

As you can see, I use a header with hyphens around for my “groups”. Then, I use a multi-line type of commenting on the different parts of the “group”. There are many ways you can organize this, but this is how I have done it for a while. I some times just use hyphens in front of the code “part”.

Code change comments

When writing this I was going back-and-forth in my head, whether I should put this under the “In-line commenting” section, or if I should dedicate a separate section for it. I feel that this was worth it’s own section.

Ok, if you put all your comments in your source-control repository, like SubVersion, GIT, CVS, etc…this might not be interesting to you, but I feel it is worth to mention.

Back in the end of the 90′s I used to work as a consultant for a company with several hundred employees. It was an international company, with offices many places around the world. They had an R&D (Research and Development) department that had set up guidelines on how to do code changes. Below is a sample on how they did the commenting (or something similar at least):

...

nPos := 0;
sToken := '';
nLength := LENGTH(sLine);
nCnt := 0;

FOR nIndex IN 1..nLength LOOP
    IF (SUBSTR(sLine, nIndex, 1) = pDelimiter) THEN
        nPosOld := nPos;
        nPos := nIndex;
        nCnt := nCnt + 1;
        -- 20130506, teab, ticket # 1234 - BEFORE:
        --sToken := SUBSTR(sLine, nPosOld + 1, nPos - 1);
        -- 20130506, teab, ticket # 1234 - AFTER:
        sToken := SUBSTR(sLine, nPosOld + 1, nPos - nPosOld - 1);
        -- 20130506, teab, ticket # 1234 - END:

        tToken_tab(nCnt).token_name := sToken;
    END IF;

END LOOP;

...

I personally find this way of commenting code a bit…too much. I had to do some code changes in some of the PL/SQL code for the accounting module for the company mentioned above, and the code just got really messy. This, since there were so many customizations compared to the core version for the project I worked on. There might be a bit more cleaner ways to do this, but in general…I almost never comment like this.

Divider comments

The last type of comments I want to mention, is what I just call divider comments. These are comments I use to i.e. divide the different procedures and functions in a package, or between the package’s variable declaration area and where the procedure and function declarations start:

	...

	-- ## -----------------------------------------------------------------## --

	FUNCTION cfill(pNbrOfFillChars IN NUMBER, pFillChar IN NUMBER) RETURN VARCHAR2 IS
		vString		VARCHAR2(100);
    BEGIN
    	vString := '';
    	FOR indx IN 1..pNbrOfFillChars LOOP
        	vString := vString || CHR(pFillChar);
        END LOOP;

        RETURN vString;
    END cfill;

	-- ## -----------------------------------------------------------------## --

	PROCEDURE pval(pNbrOfFillChars IN NUMBER, pFillChar IN NUMBER, pString IN VARCHAR2) IS
    BEGIN
    	dbms_output.put_line(cfill(pNbrOfFillChars, pFillChar) || pString);
    END pval;

	-- ## -----------------------------------------------------------------## --

	...

I try to make these dividers searchable. That is the reason I use “##” in the comment. Then I can easily search to the next declaration part in a large package.

Conclusion

Well, as you can see, there are many different ways to do commenting in PLSQL code. And, as mentioned in this article, there are also different reasons to comment.

I hope you comment in your PL/SQL (or any other programming language) code. To me it is all about readability. Even if you don’t feel that you need any comments here and now, you might wish you had commented your advanced arbitrage (i.e.) package three years ago.

I hope you have gotten some input about commenting your PL/SQL code. If you enjoyed the article, please share it on your favorite social media channel. And, if you have any other suggestions, or comments: Use the comment section below.

The post Commenting in PLSQL – Who Cares appeared first on OracleTuts.

In this post a I am going to let you know a little bit how I do most of my SQL queries. Know, that most of this are things I have found helpful as..should we say…”standards” for how I do my SQLs. But, if you are pretty new to Oracle SQL, or any other kind of SQL, there should be some nice pointers for you here.

So, let’s get started!

Editor Setup

Before we get into the SQL specific formatting, I feel it is important to mention a little bit about how I set up any of my editors. After all, most of the formatting you do is usually set up in your editor. During my workday I actually use several types of editors:

But, the common thing about all my editors, is that they are all set up the same way, even to the same colors some times.

In my opinion, setting up your SQL editor is one of the most important things you do. The reason is that you would want the formatting of your SQL to look the same, no matter what editor you view it in. If you in one editor use the tab character, and in another editor use some sort of “fill with spaces” functionality when you press the tab key…you might end up with some messy formatting.

So, that is why I try to do my best to do the same everywhere. But, enough talking – here are some of the things I always set up. To be blunt, if an editor does not handle these settings, I choose another editor.

Ok, so let us look at some of the other things that I consider.

Indentation and element placement

Ok, although I spoke about indentation under the editor setup, I also wanted to mention WHAT I usually indent. Also, where do I put what? They say that a picture is worth 1,000 words, so here is a sample of something I usually do:

1. Keywords: They are always set up in my editor to be UPPERCASE. This has been a standard for me since I started with Oracle SQL and PL/SQL. If the editor does not make the key word with the right case, I sometimes make it uppercase myself… Yes, I am that picky.
2. Indentation: All the vertical lines you see on the image above, are actually from my Notepad++ editor. It shows each of the “tab” stops in the code. As you can see, I always go to the next tabstop. What I mean is, when I have written the word “SELECT” I push the tab button. I almost never use a space, unless it is between two keywords, like between “YEAR FROM” on the above image.
3. Aliases: For me it is important to use aliases in a helpful way. If you alias your tables “A”, “B”, “C”, etc…you will find that you end up having to look back to what you called “A”. I find it much better to alias my tables “ord” for orders, “cus” for customer, “inv” for invoice, etc.But, in the sample in the image above, you see that I use “x”, and “y” as aliases. I use these letters sometimes when I have to wrap a query around another query, as seen above.
4. Parenthesis: I have been a software developer for about 25 years, so I know a lot about logical expressions. I try to use parenthesis everywhere there is any type of calculation, or expression.
5. Commas: Ok, this is a place where I differ from many… I like the comma to be on the left side. The reason is that it is a lot easier to comment each of the lines in the SQL then.

ANSI SQL

I will probably start a war on this one, but it has to be said. In any of my SQL statements, you will NEVER see any use of ANSI type of SQL. I have always worked in Oracle shops, so for me there is no need to use any:

SELECT	*
FROM	a
LEFT OUTER JOIN b ON (a.type = b.key)

I am a (+) kind of guy:

SELECT	*
FROM	a
	,b
WHERE	a.type(+) = b.key

Although Oracle has supported ANSI SQL for a while, I have never liked it, and to me it looks really messy. But, that is just my opinion.

Together with a colleague I had to go through a humongous SQL query from a SQL Server database, using T-SQL. We almost gave up when there were LEFT OUTER JOIN ON A…LEFT OUTER JOIN ON C….LEFT OUTER JOIN ON D, etc, etc.

Nope, it is not for me.

Visualize the result

In addition to my own projects, where I use a lot of PL/SQL and SQL, I am sometimes asked by my company’s Business Analysts to validate their SQL, or any other way help them to solve any SQL task or project.

Since I consider myself as a visual learner, it is important to me to somehow visualize what the outcome of the SQL query will be. Usually I write down the columns of a piece of paper, on my white-board, or sometimes I have the Business Analyst provide me with an Excel spreadsheet “mock-up”.

Sometimes it is easier to “see” how to attack your SQL, when you know what the outcome is supposed to look like. Some times you know that you will end up with a large and complicated SQL statement, and you have no clue where to start. Visualizing it helps me.

Step-by-step

When you know you that you might end up with a large SQL statement, you don’t start from the top, and then write the code line for line. You start from the “inside”. Here are some steps that I follow:

1. Driving table: In a more complex SQL statement task, you need to establish what I call the driving table. Let us say that you are going to get the orders for last week, then you are going to check the payments for those orders, and then lastly add some information about the customers on those orders. For me, the logical driving table would be the orders table.
   
2. Additional tables: When I started with Oracle SQL, back in 1997, I learned that you should (in your FROM statement) start with your driving table, and then add tables to the left of the driving table. Today the Oracle optimizer is very smart, so it probably does not matter anymore. But, I still practice this old-fashioned way of thinking. I put my next-to-driving table above my driving table, so basically if you put it on one line…it would be to the left of the driving table. Then, as I go on, I put additional tables above.
3. The inner query: If you know that you are going to add a lot of customer information to your query, but your main query has some summarizations on the orders table, I would do the the summarization first. So you would i.e. select the customer id, from the orders table, and then do a GROUP BY on that field. Then I would wrap another query around the inner query.

   SELECT	x.customer_id
   		,c.cust_first_name
           ,c.cust_last_name
           ,c.credit_limit
   		,x.order_total
   FROM	oe.customers c
   		,(
               SELECT	o.customer_id
                       ,SUM(o.order_total) order_total
               FROM	oe.orders o
               GROUP BY o.customer_id
   		) x
   WHERE	c.customer_id = x.customer_id
   ;

   The reason I do this, is that I do not like to do a GROUP BY on more fields than I need to. Besides, it looks a lot cleaner to me.

4. Repetive queries: Let us say that you are doing a query that is similar to the one shown under point # 3, and you a bit later (on a different level) in your query select the similar query, but for the same time period last year. To me, a bell would ring, telling me to consider using a WITH statement. I will go through the WITH statement and it’s use in a future tutorial.
5. Use of SELECT *: I never use SELECT * for any query that is going to be used in any analytic scenario. I always specify the names of the few fields I need going along. It would then be easier to avoid “duplicate column names”. What I mean, is that if you have a SELECT * on the orders table, joined with a SELECT * on the customers table, and then wrap a query around it.. If you then in your outer query “SELECT customer_id…”, you would probably get an error, since the pre-compiler would not know which of the customer_id fields you were speaking about.

SQL Formatters

What do you do if you have an editor that does not format your SQL query very well? There are many free SQL Formatters available on the Internet. Here are a few examples:

But, these online tools would just be a backup solution for me. To me it is important to have tool available that do all the formatting you need for your SQL statements. The tool I have been using since I started as an Oracle developer, is PL/SQL Developer from Allround Automations.  PL/SQL Developer has an awesome feature, called “PL/SQL Beautifier“. You can set up your own rules on how you want your SQL query to look. So, if you get a query from some old view in the database, that looks totally messed up, you can mark the query and “beautify” it, based on your own rules. It can come in really handy. Here is a screenshot:

You can order PL/SQL Developer by clicking on the green button:

* Affiliate link. For other license options than “single user“, please contact me through the contact page on my blog.

Conclusion

To me, writing a SQL statement can sometimes be like a piece of “art”… It is all about  the “looks” and readability. Not just for you, but for anyone that looks at your SQL code.

Now, if you get your whole team to follow the same standards…life is just golden! But, sometimes there are people in your team that have different experiences than you, and you might not be able to nail your your “law” to the wall as something everyone has to follow.

Based on experience working in large teams, the best thing is to come up with some common ground, and write down a short document that everyone agrees upon. I have even worked for a large company with it’s own R&D (Research and Development) team, setting all the standards for the whole company.

After reading all this, you might think “he’s just crazy picky”, or something. But, all these things are just “there” in my fingers, and in my head when I code SQL statements.

I hope this post has been of value to you. As always: “Sharing is caring“.

Also, if you have any thoughts, or other ideas…let us all know by leaving a comment.

~ TJ

The post Formatting SQL – Best Practices appeared first on OracleTuts.

You might not get that kick-start of your knowledge base like you were expecting, because your team has a big delivery next month, and no-one really has time to sit down with you. But, at the same time, YOU are expected to come up-to-speed so that you can help to pull some of the weight in your team.

This is a very typical situation for many new developers, and in this article I wanted to tell you about 11 ways to increase your Oracle skills. But, of course, you can use these 11 ways as any type of developer.

1. Classes (off site, virtual)
2. In-house classes
3. On site classes
4. Learn from others in your team
5. Forums
6. Books
7. Videos
8. Oracle User groups
9. Libraries
10. Learn by example
11. Blogs and Websites

Below, I have divided these 11 ways to increase skills into two groups:

Taught by others

1. Classes (on site, virtual)

One of the most common ways, for at least larger companies, to educate new developers is to send the newbie to a place where they give classes in what your are supposed to become an expert in. There are many companies that specializes in Oracle training, and you can search the Internet for these companies. Another variant that I like very much, is the “virtual class” type of courses. I am a “home-body”, and I do not care much for traveling, so I prefer sitting in my private office at home, and take a virtual class instead of going to a hotel for a few days. That is just me…

The virtual classes are usually organized so that you have an instructor that shares his/her computer screen, and all participants call a number so that you can all be part of the class, and ask questions to the instructor.

If you do not have your own home office, maybe you can schedule one of your company’s meeting rooms for a few days so that you can get some peace and quiet?

2. In-house classes

Depending on the work load in your team, or company, a very nice way yo learn is in-house classes. This is a class where people from your company come together, and one of your company’s knowledgeable people gives a class on a topic. This might often work very well, since you all belong to the same company, and the instructor will be able to help you more when you have questions on matters that are based on some of the rules and regulations of the company, guidelines for developers in your company, etc.

Currently I am actually giving SQL classes to some of my colleagues, and it can be a very nice way to learn.

3. On site courses

A way used by some companies, is to gather some of the developers, and then have the company pay for an instructor to come to YOU. So, it is basically the same as the first, but instead of YOU traveling, the instructor is traveling.

One of the nice things about using this way of classes, is that the instructor can be told up front specific topics that needs to be covered more deeply, etc.

4. Learn from others in your team

Well, as I mentioned in the beginning of this article, the IT department can be a hectic place sometimes, and it is not always time for someone in your team to sit down with you to teach you. And, I am sorry…but humans are just…humans, so psychologically,  the person set to teach you might not even WANT the task of teaching you, or he/she will look at you as a “lesser worth” person because you know so little. I migth be weird to say this, but there are too many examples in an IT department of these situations, so I felt I needed to mention this.

So, if you get the right person in your team to teach you, this can be an awesome experience.

Another issue, you might call it, is that even if you are lucky to get a good experience with being taught by a colleague, it can start out well, but after a couple of weeks the trainer/colleague is pulled into a big project, and you are left by yourself again.

Self Learning

Ok, now we are getting into my favorite ways to increase skills. At the time of writing this article, I have worked as a software developer for almost 25(!) years. The best way for me, personally, is to teach myself. This way I can teach myself on only the topics that matters.

Here are some of the ways I use all the time as a software developer.

5. Forums

There are many good Oracle forums out there, and here are few examples:

6. Books

There are definitively a lot of Oracle books available. You can find most of them at Amazon. A nice thing about many books, is that they come in .PDF format. That makes it so that you can have it on the computer, and search for words in the books, etc. In addition, with a .PDF book, you can have it on your iPad, if you have one.

7. Videos

If you have something you want to know about as an Oracle developer, a nice way to learn is to i.e. go to Google, and search for videos on a certain topic, or even beginner tutorials. You can use this link.

8. Oracle User groups

In most areas of  the world, you will be able to find Oracle User Groups. Search for them in your favorite search engine, and see if there is one close to you. Also, a lot of the bigger Oracle User Groups have their own website, that you can find i.e. by using Google.

9. Libraries

Ok, I am not speaking about the public library, with all them books. I am speaking about websites made as a “library” to help people that search for how to use a function, how to use a command, how to write a certain type of SQL statement, etc.

Here are a couple of them:

You can search the Internet for many more of them.

10. Learn by example

This is something I like personally. Many a time I have learned how to do something by looking at other developer’s code. Like, if you are working in a team with many other developers, you will have a database where all the procedures, functions, and packages are residing. Browse through them, and see how things are being done.

In the latest years, a very often used way to store code files is by using web based code repositories, like GIT, etc. Many companies have these installed internally. You can ask to get access to these repositories, and look through some of the code.

11. Blogs and Websites

Well, I would hope you use OracleTuts, but there are a lot of blogs about Oracle on the Internet. I will leave up to you to do the search. But, a very well known one is the “Ask Tom” website, which is a part of Oracle’s website, and the “Tom” we are speaking about is the well know Oracle personality Tom Kyte.

Conclusion

I am a very blessed person, in many ways. And, one of the ways is that I have a beautiful wife that I love very much. On of the ways I am very different than my wife, is in studying. My wife likes to read the whole book, but I prefer to look at the few paragraphs that solve my problem. The main difference might be that I am a technical person, and my beauty is not. Also, my wife likes to learn about many different things, but I like to be topic-oriented.

There are many different ways to learn, but if you want to go the “self-taught” way like I have, I would encourage you to specify the issue you have, or define exactly what you want to learn about, and then learn about it. Like I do:

I have a task, I get an issue, I look on the Internet how to solve it, and then I solve it. Short and sweet.

Well, that was the end of this article. I hope you have enjoyed it, and have learned form it. Please do not hesitate on leaving a comment, and if I have forgotten something, please put your way to learn in the comments section below.

And, as always, sharing is caring.

The post 11 Ways to Increase Your Oracle Skills appeared first on OracleTuts.

This tool can be used for many types of data imports into an Oracle table.

Introduction

Working with Oracle SQL and PL/SQL since 1997, I have done a LOT of text import of data. Usually what I have done is to open i.e. a .CSV file in Excel, and add columns, so that when I save the file back to the .CSV file again, it creates a series of INSERT INTO statements. This way of preparing the data, and then import the data is just time consuming. There is a much better way.

In this video we will

1. Create a table named “customer”
2. Import a .CSV text file into the table
3. Select from the “customer” table

Very simple, this tool is just awesome.

If you have any other experiences with this text import tool, please leave a comment so that we all can know a bout it.

~ TJ

The post How To Perform A Text Import With PL/SQL Developer appeared first on OracleTuts.

Hey everyone!

I am TJ Abrahamsen, the creator and owner of OracleTuts.net. I have been working full-time with Oracle SQL and PL/SQL since 1997. My specialty is Oracle SQL and PL/SQL.

OracleTuts.net was created to share my experience with Oracle SQL and PL/SQL. My goal with the site is to help you to become experienced within these topics as well, if you are not already.

I really hope you enjoy my site, and that you will leave a comment if you like the content on OracleTuts.net.

Enjoy the site!

~ TJ

The post Welcome to OracleTuts! appeared first on OracleTuts.

Introduction

The default setup in SQL Developer has the plain white background. If you are a developer like me, and look at the screen all day long…you might want to consider changing the background color to a little bit darker setting to save your eyes a bit.

In this video we will

1. Extract the default Fusion Blue jar file into a temporary folder
2. Change some of the content in the copied jar file
3. Compress our changed content, to a new jar file
4. Copy the new jar file to the theme folder
5. Change a setting inside SQL Developer
6. Restart SQL Developer

The post How to Change Background Color in Oracle SQL Developer appeared first on OracleTuts.

Introduction

A while ago I wrote a tutorial on how to transpose rows to columns using Oracle SQL. You can find the tutorial here: Three Ways To Transpose Rows Into Columns in Oracle SQL

Many people would like to know how to do it the opposite way, transpose columns to rows, as well. So, here is a tutorial that shows a couple of ways you can do this.

Examples

In the tutorial we will pretend we have a survey table where the people taking the survey have filled out a form about what health concerns they have. Yes for a concern will be “1″ in the table, and No will be “0″ in the table.

We have the following records in the table:

SQL> SELECT	*
  2  FROM	survey
  3  /

                              SURVEY_ID CONCERN_EYE CONCERN_VISION CONCERN_BRAIN CONCERN_LUNG CONCERN_HIP
--------------------------------------- ----------- -------------- ------------- ------------ -----------
                                    123 0           0              1             0            1
                                    321 1           1              0             0            0
                                    456 0           0              0             0            0
                                    654 1           1              0             1            1
                                    789 0           1              0             0            0
                                    987 0           0              0             0            1

6 rows selected

For one of our company’s reports, we need to come up with a SQL query where the columns are represented as rows – meaning that we have transposed the columns to rows.

Example # 1: Using the UNION operator

In this sample, we will solve the task simply by using several UNION statements. Our end result should be a resultset with 30 records. The reason for this is that we have six (6) unique ids, and we have five (5) columns for each of the ids. And… 6 x 5 = 30

SQL> WITH survey_query AS	(
  2                              SELECT	*
  3                              FROM	survey s
  4                          )
  5  SELECT	sq.survey_id
  6          ,'EYE' concern_type
  7          ,sq.concern_eye concern_flag
  8  FROM	survey_query sq
  9  UNION
 10  SELECT	sq.survey_id
 11          ,'VISION' concern_type
 12          ,sq.concern_vision concern_flag
 13  FROM	survey_query sq
 14  UNION
 15  SELECT	sq.survey_id
 16          ,'BRAIN' concern_type
 17          ,sq.concern_brain concern_flag
 18  FROM	survey_query sq
 19  UNION
 20  SELECT	sq.survey_id
 21          ,'LUNG' concern_type
 22          ,sq.concern_lung concern_flag
 23  FROM	survey_query sq
 24  UNION
 25  SELECT	sq.survey_id
 26          ,'HIP' concern_type
 27          ,sq.concern_hip concern_flag
 28  FROM	survey_query sq
 29  /

                              SURVEY_ID CONCERN_TYPE CONCERN_FLAG
--------------------------------------- ------------ ------------
                                    123 BRAIN        1
                                    123 EYE          0
                                    123 HIP          1
                                    123 LUNG         0
                                    123 VISION       0
                                    321 BRAIN        0
                                    321 EYE          1
                                    321 HIP          0
                                    321 LUNG         0
                                    321 VISION       1
                                    456 BRAIN        0
                                    456 EYE          0
                                    456 HIP          0
                                    456 LUNG         0
                                    456 VISION       0
                                    654 BRAIN        0
                                    654 EYE          1
                                    654 HIP          1
                                    654 LUNG         1
                                    654 VISION       1
                                    789 BRAIN        0
                                    789 EYE          0
                                    789 HIP          0
                                    789 LUNG         0
                                    789 VISION       1
                                    987 BRAIN        0
                                    987 EYE          0
                                    987 HIP          1
                                    987 LUNG         0
                                    987 VISION       0

30 rows selected

As you can see, we got our 30 records. Also, note that I used a WITH statement for my main query. This is because I want to make sure that my query does not pull data from the survey table five times, but only once.

Example # 2: Using the UNPIVOT operator

If you have a database with Oracle database version 11g or later, you might consider using the UNPIVOT operator to solve your task.

Here is a sample:

SQL> SELECT	survey_id
  2  		,concern_type
  3          ,concern_flag
  4  FROM	survey
  5  UNPIVOT (	concern_flag FOR concern_type IN (
  6  				concern_eye AS 'EYE'
  7                  ,concern_vision AS 'VISION'
  8                  ,concern_brain AS 'BRAIN'
  9                  ,concern_lung AS 'LUNG'
 10                  ,concern_hip AS 'HIP')
 11  		)
 12  /

                              SURVEY_ID CONCERN_TYPE CONCERN_FLAG
--------------------------------------- ------------ ------------
                                    123 EYE          0
                                    123 VISION       0
                                    123 BRAIN        1
                                    123 LUNG         0
                                    123 HIP          1
                                    321 EYE          1
                                    321 VISION       1
                                    321 BRAIN        0
                                    321 LUNG         0
                                    321 HIP          0
                                    456 EYE          0
                                    456 VISION       0
                                    456 BRAIN        0
                                    456 LUNG         0
                                    456 HIP          0
                                    654 EYE          1
                                    654 VISION       1
                                    654 BRAIN        0
                                    654 LUNG         1
                                    654 HIP          1
                                    789 EYE          0
                                    789 VISION       1
                                    789 BRAIN        0
                                    789 LUNG         0
                                    789 HIP          0
                                    987 EYE          0
                                    987 VISION       0
                                    987 BRAIN        0
                                    987 LUNG         0
                                    987 HIP          1

30 rows selected

As you can see, we have the same amount of records.

In the query above, the “concern_type” and the “concern_flag” fields can be named anything.

Conclusion

Ok, so we have seen two different ways to transpose columns into rows in Oracle, using SQL. The first example might be a good way, but it requires a little bit more code.

The second example, using UNPIVOT, is a good way to go if your database version is 11g or newer. There are though a few things to be aware of using the UNPIVOT operator, especially when using aliases.

I hope this has been helpful for you. If you liked this post, please share this post with others

~ TJ

The post How To Transpose Columns To Rows In Oracle appeared first on OracleTuts.

• Top 10 Tips & Tricks for Oracle SQL Developer
• Oracle Magazine
• 15 Things You Should Know about the ORDER BY Clause
• Oracle FAQ’s
• Morgan’s Library

Top 10 Tips & Tricks for Oracle SQL Developer

By Jeff Smith

I’ve been sharing 1-3 tips or ‘tricks’ a week since I started blogging about SQL Developer, and I have more than enough content to write a book. But since I’m lazy, I’m just going to compile a list of my favorite ‘must know’ tips instead. I always have to leave out a few tips when I do my presentations, so now I can refer back to this list to make sure I’m not forgetting anything.

Read the complete post here …

Oracle Magazine Online

By Oracle

I have been receiving the Oracle Magazine for a while, and love it. I used to get it in printed format, but these days I receive it in an electronic format, for online reading. If you do not already subscribe to Oracle Magazine, I would definitely suggest that you check it out. It has a lot of news about Oracle. And, Steven Feuerstein usually have an awesome section on PL/SQL. Lately he has been speaking about PL/SQL Cursors.

Check it out here

15 Things You Should Know about the ORDER BY Clause

By Oratable

1. When multiple columns/expressions are specified in the ORDER BY clause, the precedence of sorting is left to right.

2. The ORDER BY clause can order in ascending (ASC) or descending (DESC) sequence, or a mix of both. If ASC or DESC is not explicitly stated, then ASC is the default.

Read the complete post here …

Oracle FAQ’s

By Oracle FAQ

The Oracle FAQ is NOT an official Oracle Support site, but rather a get-together of people with jobs in Oracle. In our spare time we come together here to learn about Oracle, share knowledge and try to help others solve their problems. In doing so, this sites puts a wealth of information at the fingertips of Oracle professionals all over the world. You can use our directories and powerful search facilities to quickly locate all the information you need. …

Check it out here

Morgan’s Library

By Daniel Morgan

The library is a spam-free on-line resource with code demos for DBAs and Developers.
If you would like to see Oracle database funtionality added to the library … just email us.
Coming soon … Oracle’s Database 12cR1. While waiting: check the section of ODA’s and ZFS.

Check it out here

The post Oracle PLSQL and SQL Blog Posts From Around the Web (10/2013) appeared first on OracleTuts.

Introduction

I work in the Data Warehouse team of a large Multi Level Marketing company. One thing I work with a lot, is dates.

Recently I had the following situation:

• For each distributor in our Philippines market that had done a purchase the last month, show the purchase amounts for the last 14 weeks for each of these distributors
• Some of the distributors have not purchased every week

So, based on the situation above, we might be missing some records if we just use i.e. our ORDERS table. This, since we know that some (or many) of the distributors have not purchased for each of the 14 weeks.

So, how can we avoid getting “holes”?

Step # 1: Get the Date Range

The first thing we would need to do to generate a date range in Oracle SQL, is to actually make sure we can actually create a SELECT that returns the data we need. There are probably many ways to do this, but here are three different methods.

Method # 1: Get the Date Range Based on a Date Table

In the database I work with on daily basis, we have a table that has a record for each date until probably 2016. I used this to get my date range.

SQL> SELECT	dd.date_key
  2  FROM	edw.dim_date dd
  3  WHERE	dd.cal_day_of_week_number = 6
  4  AND		dd.date_key BETWEEN TO_DATE('20130225', 'YYYYMMDD') - (7 * 14) AND TO_DATE('20130225', 'YYYYMMDD')
  5  ORDER BY dd.date_key
  6  /

DATE_KEY
-----------
11/23/2012
11/30/2012
12/7/2012
12/14/2012
12/21/2012
12/28/2012
1/4/2013
1/11/2013
1/18/2013
1/25/2013
2/1/2013
2/8/2013
2/15/2013
2/22/2013

14 rows selected

In my company, we use a “commission week”, which always ends on a Friday. Since I wanted the Fridays, I used cal_day_of_week = 6 in line # 3.

Method # 2: Get the Date Range Based on a “dummy” Table

Another way to get a date range is to use any table that you know will have the amount of records that you will need for your date range

SQL> WITH dateqry AS (
  2                      SELECT	TRUNC(SYSDATE) - ROWNUM dateval
  3                      FROM	all_objects
  4                      WHERE	ROWNUM < (7 * 14)
  5  				)
  6  SELECT	*
  7  FROM	dateqry dq
  8  WHERE	TO_CHAR(dq.dateval, 'DY') = 'FRI'
  9  /

DATEVAL
-----------
2/22/2013
2/15/2013
2/8/2013
2/1/2013
1/25/2013
1/18/2013
1/11/2013
1/4/2013
12/28/2012
12/21/2012
12/14/2012
12/7/2012
11/30/2012
11/23/2012

14 rows selected

We still get the dates we want…

Method # 3: (Preferred) Get the Date Ranges Based on The Oracle Dual Table

I believe this method would be the preferred method to get the dates we need for the next step. In this method, we are actually using the Oracle dual table, which only contains one record!

Here is how you can do that, using a CONNECT BY

SQL> SELECT	x.dateval
  2  FROM	(
  3  			SELECT	(TRUNC(TO_DATE('20130225', 'YYYYMMDD')) - ROWNUM) + 1 dateval
  4  			FROM	dual CONNECT BY ROWNUM < (7 * 14)
  5  		) x
  6  WHERE	TO_CHAR(x.dateval, 'DY') = 'FRI'
  7  /

DATEVAL
-----------
2/22/2013
2/15/2013
2/8/2013
2/1/2013
1/25/2013
1/18/2013
1/11/2013
1/4/2013
12/28/2012
12/21/2012
12/14/2012
12/7/2012
11/30/2012
11/23/2012

14 rows selected

And…we got our 14 previous Friday records.

SELECT	x.dateval
FROM	(
            SELECT	(TO_DATE('20080111', 'YYYYMMDD') + ROWNUM) + 1 dateval
            FROM	dual 
            CONNECT BY ROWNUM < ((TRUNC(SYSDATE + 1, 'd') - 2) - TO_DATE('20080111', 'YYYYMMDD'))
		) x
WHERE	TO_CHAR(x.dateval, 'DY') = 'FRI'
ORDER BY x.dateval
;

Step # 2: Put it together

Ok, so we now have decided on the method to get our date range. Let’s put it into action, for some practical use.

To avoid returning too many records for this sample, I picked out only two distributors. As you can see, these people do not have a purchase for all of our 14 weeks:

SQL> SELECT	o.commission_date
  2  		,o.customer_id
  3  FROM	odsy.orders o
  4  WHERE	o.commission_date BETWEEN TRUNC(SYSDATE + 1, 'd') - 2 - (7 * 13) AND TRUNC(SYSDATE + 1, 'd') - 2
  5  AND		o.ship_to_country_code = 'PH'
  6  AND		o.customer_id IN (8001636, 6722194)
  7  ORDER BY	o.commission_date
  8  			,o.customer_id
  9  /

COMMISSION_DATE CUSTOMER_ID
--------------- -----------
11/23/2012          8001636
12/21/2012          8001636
1/18/2013           8001636
1/18/2013           8001636
1/18/2013           8001636
2/8/2013            6722194
2/15/2013           6722194
2/22/2013           6722194
2/22/2013           8001636

9 rows selected

So, here comes the real trick. We are actually going to force a CARTESIAN JOIN to make sure we have the correct number of records.

SQL> SELECT	dt.dateval
  2  		,ord.customer_id
  3  FROM	(
  4              SELECT	o.customer_id
  5              FROM	odsy.orders o
  6              WHERE	o.commission_date = TRUNC(SYSDATE + 1, 'd') - 2
  7              AND		o.ship_to_country_code = 'PH'
  8              AND		o.customer_id IN (8001636, 6722194)
  9  		) ord
 10  		,(
 11              SELECT	x.dateval
 12              FROM	(
 13                          SELECT	(TRUNC(TO_DATE('20130225', 'YYYYMMDD')) - ROWNUM) + 1 dateval
 14                          FROM	dual CONNECT BY ROWNUM < (7 * 14)
 15                      ) x
 16              WHERE	TO_CHAR(x.dateval, 'DY') = 'FRI'
 17  		) dt
 18  /

DATEVAL     CUSTOMER_ID
----------- -----------
2/22/2013       6722194
2/15/2013       6722194
2/8/2013        6722194
2/1/2013        6722194
1/25/2013       6722194
1/18/2013       6722194
1/11/2013       6722194
1/4/2013        6722194
12/28/2012      6722194
12/21/2012      6722194
12/14/2012      6722194
12/7/2012       6722194
11/30/2012      6722194
11/23/2012      6722194
2/22/2013       8001636
2/15/2013       8001636
2/8/2013        8001636
2/1/2013        8001636
1/25/2013       8001636
1/18/2013       8001636
1/11/2013       8001636
1/4/2013        8001636
12/28/2012      8001636
12/21/2012      8001636
12/14/2012      8001636
12/7/2012       8001636
11/30/2012      8001636
11/23/2012      8001636

28 rows selected

As you can see, we now have 14 records for each of these two distributors, all together 28 records. This is exactly what we need as our base to solve our task. We will now have to join this query with whatever other tables we need to get the data we need (not shown in this example).

Summary

As we have seen, there are at least three different ways to get date ranges in Oracle. If you do not have a date table (with records for each of the dates for multiple years, I would recommend method # 3 shown above.

Also, we can force a CARTESIAN JOIN to make sure we have all the records we need. In general: Be aware of CARTESIAN JOINS, and avoid them wherever you can.

If you have comments, or have other ways to do this…please let us all know.

I hope you enjoyed this tutorial,

TJ

The post How To Generate Date Range In Oracle SQL? appeared first on OracleTuts.

Introduction

Aggregate functions are common in most (if not all) relational database management systems (RDBMS).

In a database like Oracle, you will find many single-row functions like SUBSTR, TO_NUMBER, ROUND, etc. These are…like the name indicates: Functions that return a single result row for each row in your resultset (the data returned back from your query).

An aggregate Function, on the other hand, return a single result row based on a group of rows.

As an example, let us pretend we have the following scenario:

• 100 people are gathered in a large empty building
• They all have a last name, and many of them actually have the same last name.

There are many ways we can look at these people. We can order them alphabetically, by age, etc. But, 100 people are a lot of people to deal with, and what we really wanted was to count how many had the different last names (just for this simple example). What we can do is to line up everyone alphabetically, and then go through all of them to write down their names…and then count.

But, what if there was a smarter way?

Aggregate Function Explained

Let us again think about the 100 people we mentioned above. What if we had some guys volunteer to organize the people into groups, one per last name. Each of the volunteers would gather their group, and when it was their turn to report back to the person that gathered all the people…they would stand up and shout: “Hansen – 10 people”, the next volunteer would yell “Bailey – 5 people”, etc.

So, basically, if we were the ones gathering the people in the building, all we would need to do would be to come in at the end to note down the different last names, and how many there were of the different names. Essentially this is what happens in the database when we use aggregate functions. We tell the database engine that we want to “gather some people”, and how we want to group them…and the database takes case of the rest.

The syntax for using an aggregate function in Oracle is:

SELECT	column_1, coumn_2, column_3,..column_n, AGGREGATE_FUNCTION(expression)
FROM	table_1, .. table_n
WHERE	where_clause
GROUP BY column_1, column_2
HAVING 	having_condition
ORDER BY column_1

Aggregate Function COUNT sample

Ok, so we have some background. Let us look at a practical example. We want to list all the last names, and then show how many there are of each of the names.

SQL> SELECT	e.last_name
  2  		,COUNT(*) name_count
  3  FROM	hr.employees e
  4  GROUP BY e.last_name
  5  ;

LAST_NAME                 NAME_COUNT
------------------------- ----------
Abel                               1
Ande                               1
Atkinson                           1
Austin                             1
/* A lot of records go here */
Cabrio                             1
Cambrault                          2
Chen                               1
Chung                              1
Colmenares                         1
Davies                             1
De Haan                            1

LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
Gietz                              1
Grant                              2

LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
King                               2
Kochhar                            1
/* A lot of records go here */
LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
Olsen                              1
Olson                              1
Sarchand                           1

LAST_NAME                 NAME_COUNT
------------------------- ----------
Smith                              2
/* A lot of records go here */
Sullivan                           1
Taylor                             2
/* A lot of records go here */

102 rows selected
SQL> /

LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
Bull                               1
Cabrio                             1
Cambrault                          2
/* A lot of records go here */

LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
Gietz                              1
Grant                              2
Greenberg                          1
/* A lot of records go here */

LAST_NAME                 NAME_COUNT
------------------------- ----------

/* A lot of records go here */
Khoo                               1
King                               2
/* A lot of records go here */

LAST_NAME                 NAME_COUNT
------------------------- ----------
/* A lot of records go here */
Russell                            1
Sarchand                           1

LAST_NAME                 NAME_COUNT
------------------------- ----------
Sewall                             1
Smith                              2
Stiles                             1
Taylor                             2

/* A lot of records go here */

102 rows selected

Please note that I skipped showing a lot of records so that you should not be annoyed scrolling through them.

So, let us shorten down the list a bit.

Aggregate Function COUNT using HAVING sample

Let us show ONLY the last names that are owned by more than one employee.

SQL> SELECT	e.last_name
  2  		,COUNT(*) name_count
  3  FROM	hr.employees e
  4  GROUP BY e.last_name
  5  HAVING COUNT(*) > 1
  6  ;

LAST_NAME                 NAME_COUNT
------------------------- ----------
Cambrault                          2
Grant                              2
King                               2
Smith                              2
Taylor                             2

Here you can see that we have used the HAVING clause to limit the data in our result set. It is kind-of the WHERE of a GROUP BY statement.

Ok, let us now pretend we want to show the last names that are owned by two or more people for only a given set of departments. This can be a sample of that:

SQL> SELECT	e.last_name
  2  		,COUNT(*) name_count
  3  FROM	hr.employees e
  4  WHERE	e.department_id IN (50, 80)
  5  GROUP BY e.last_name
  6  HAVING COUNT(*) > 1
  7  ;

LAST_NAME                 NAME_COUNT
------------------------- ----------
Taylor                             2
Cambrault                          2
Smith                              2

Above we used both a WHERE and a HAVING. What will happen in this query is that it will select employees from the given departments, and then group the people.

You can also use two (or more) aggregate functions in your SELECT part of your query, and still only use one of these functions in your HAVING filter. As shown in this example:

SQL> SELECT	e.last_name
  2  		,COUNT(*) name_count
  3          ,SUM(e.salary) salary_sum
  4  FROM	hr.employees e
  5  WHERE	e.department_id IN (50, 80)
  6  GROUP BY e.last_name
  7  HAVING SUM(e.salary) > 15000
  8  ;

LAST_NAME                 NAME_COUNT SALARY_SUM
------------------------- ---------- ----------
Cambrault                          2      18500
Smith                              2      15400

The GROUP BY columns

As you see from the query above, we are GROUPing our data on the last_name. But, you can group on more than one column. If you again look at the query above, you can SELECT any column from the employee table, but all the columns you SELECT has to be present in your GROUP BY clause.

But, you can GROUP BY any columns from the employee table, even if they are not present as your SELECT columns.

Also, note that the order of the columns in your GROUP BY clause might matter in some situations The most important column to GROUP BY is the most left one on your GROUP BY line.

Additional Aggregate Functions in Oracle

In addition to the COUNT and SUM used in the queries above, there are many different aggregate functions in oracle. If you want to read more about these functions, I would suggest you take a look at the Oracle documentation:

Oracle 11g R2 Aggregated Functions

If you have any questions about aggregate functions, please leave a comment so that we can all help each other.

~ TJ

The post Introduction To Aggregate Functions In Oracle appeared first on OracleTuts.