Catálogo de publicaciones - libros

In this chapter, we explored many areas of loading data. We covered the typical day to day things we will encounter — the loading of delimited files, loading fixed length files, the loading of a directory full of image files, using functions on input data to transform them, unloading data, and so on. We did not cover massive data loads using the direct path loader in any detail. Rather, we touched lightly on that subject. Our goal was to answer the questions that arise frequently with the use of SQLLDR and affect the broadest audience.

To conclude this book, I’ve presented some of the more advanced topics found within the .NET Framework and Mono. First, you saw how to assess the performance of your application using both built-in and additional . This followed with a discussion on how to address performance, assuming that you have first diagnosed the problem(s) using profiling. I then introduced the topic of reflection, showing how you can obtain introspective information on your assemblies and classes at runtime using the reflection application programming interface. You also looked at increasing your application’s response time yet further by tapping into the power of multithreaded applications, allowing (what often appears to be) simultaneous processing of code. Finally, I provided some tips on how to work toward the utopia of true interoperability between your applications running on different operating systems.

In this chapter, we thoroughly explored the Optimizer Plan Stability feature of Oracle8i. This feature was designed to allow a set of SQL statements performance to remain stable, regardless of changes in the database itself (for example, version upgrades, init.ora parameter changes, and so on). We have found some other useful functions of this feature, such as tuning applications that we cannot modify for whatever reason, finding out what indexes we really use, what SQL we really execute, and so on. Given that stored outlines are so transparent to an application, and add little or no overhead at run-time, their usefulness is increased. There are some crucial caveats to be aware of with regards to this feature, but once educated about them, stored outlines can be very powerful.

In this chapter, we thoroughly explored the syntax and implementation of analytic functions. We have seen how many common operations such as running totals, pivoting resultsets, accessing ‘nearby’ rows in the current row and so on are now easily achieved. Analytic functions open up a whole new potential for queries.

To conclude this book, I’ve presented some of the more advanced topics found within the .NET Framework and Mono. First, you saw how to assess the performance of your application using both built-in and additional . This followed with a discussion on how to address performance, assuming that you have first diagnosed the problem(s) using profiling. I then introduced the topic of reflection, showing how you can obtain introspective information on your assemblies and classes at runtime using the reflection application programming interface. You also looked at increasing your application’s response time yet further by tapping into the power of multithreaded applications, allowing (what often appears to be) simultaneous processing of code. Finally, I provided some tips on how to work toward the utopia of true interoperability between your applications running on different operating systems.

To conclude this book, I’ve presented some of the more advanced topics found within the .NET Framework and Mono. First, you saw how to assess the performance of your application using both built-in and additional . This followed with a discussion on how to address performance, assuming that you have first diagnosed the problem(s) using profiling. I then introduced the topic of reflection, showing how you can obtain introspective information on your assemblies and classes at runtime using the reflection application programming interface. You also looked at increasing your application’s response time yet further by tapping into the power of multithreaded applications, allowing (what often appears to be) simultaneous processing of code. Finally, I provided some tips on how to work toward the utopia of true interoperability between your applications running on different operating systems.

In this chapter we thoroughly explored the feature of autonomous transactions. We have seen how they can be used to generate more modular, safe code. We have seen how they can be used to do things that have previously not been possible, such as performing DDL in a trigger or running any stored function via a SELECT statement, regardless of whether that function wrote to the database or not. We also saw that it is not wise to think you know exactly how many times a function called from SQL will actually be called, so be careful when writing to the database state in that fashion. We have seen how this feature can be used to avoid a mutating table error, as well as how this feature might lead to the ‘wrong’ result when used incorrectly to solve this problem.

Autonomous transactions are a powerful feature that Oracle itself has been using for years in the guise of recursive SQL. It is now available for you to use in your applications as well. A thorough understanding of transactions, how they work, where they start, and when they end, is mandatory before utilizing this feature, as various side effects can occur. For example, a session can deadlock itself, a parent transaction may or may not see the results of the child autonomous transaction, a child autonomous transaction cannot see outstanding work of the parent, and so on.

In this chapter we thoroughly explored dynamic SQL in stored procedures. We have seen the differences between native dynamic SQL and DBMS_SQL, showing when to use one over the other. Both implementations have their time and place. Dynamic SQL allows you to write procedures that are otherwise impossible - generic utilities to dump data, to load data, and so on. Further examples of dynamic SQL-based routines can be found on the Apress web site, such as a utility to load dBASE III files into Oracle via PL/SQL, printing the results of a query down the page in SQL*PLUS (see , Chapter 23), pivoting resultsets (see , Chapter 12 for details on this), and much more.

In this chapter, we examined the rich feature set of interMedia Text, and how it can be easily exploited in a variety of applications. Although this chapter covered many facets of interMedia Text, there are still many more things I haven’t covered. You can use a thesaurus, define a custom lexer, generate HTML renditions of all of your documents regardless of format, store your query expressions for later use, and even define your own custom stopword lists.

interMedia Text itself is a very broad topic, and one which can’t be covered in a single chapter. Besides being very feature-rich, interMedia Text is quite easy to use and understand. After reading this chapter, you should now have a clear understanding of how interMedia Text is implemented, and also how you can exploit the power of interMedia Text in many of your applications.

In this chapter, we have covered the main issues surrounding external procedures such as:

Given the generic template and makefiles above, you have all you need to write an external procedure from start to finish in a couple of minutes now. The tricky part is mapping the datatypes and the tables above, but that is easily accomplished by following the two tables in section - they tell you ‘given this type, you will use that type’. Then, just follow the guidelines I have for passing the parameters in the example above (always send the context, always send the MAXLEN attribute for strings and raws, always send the Null indicator, and so on). If you do that, you’ll be writing external procedures in no time.