How does SQL Sprocket work?

The output generation is based on three types of templates, and the list of tables found in your database:

• Table List Statement – User Mode
• Metadata Templates – Advanced Mode
• Dictionary Templates – Advanced Mode
• Output Templates – User Mode

Table List

You have full control over the way your database tables are listed in SQL Sprocket. Use the default or update the SQL that populates the list of database tables to your preference.

Metadata Templates

Metadata templates give you control over how the data is queried from the SQL Server database and the information provided to the Dictionary Templates. If Microsoft makes any changes to the SQL Server Information_Schema views in a later release just make a quick update to the Metadata Template and you are back to work.

Dictionary Templates

Most users will never need to touch the Dictionary or Metadata Templates, but the flexibilty to change how the output is generated using C# or TSQL is available If you need more output types or just want to change the default processing, Dictionary Templates make it possible to tailor the output generation to your needs.

Output Templates

Output Template allow you to use the data collected from your database schema along with the <OUTPUT> parameters to generate your database code the way you want it.

How easy is it to use?

There is no complex syntax to learn, and you can start generating output based on your SQL Server database in minutes.

1. Start the tool and connect to your SQL 2012, 2005, or 2008 database.
2. Create the Output templates for your specific development needs or use the TSQL templates provided.
3. Select the tables and templates you want to use to generate code.
4. Click Execute and generate your code.
5. Copy the code to a script or compile it against your database.

SQL Sprocket allows you to define your own generation templates using C# code or TSQL, but did not ship with a TSQL generator out of the box. As a contributor to the SQL Sprocket project, I am pleased to announce the availability of a an example TSQL generator for SQL Sprocket.

I have published both my TSQL generator file and all the output templates I created for the Fulcrum SKMS project. The plan is to provide future templates and updates on the SQL Sprocket Project download page as they are developed.

I hope you will give SQL Sprocket a try and let us know what you think.

Real Application Clusters (RAC) allows multiple computers to run Oracle software simultaneously while accessing a single database, therefore providing a clustered database. In the previous non-RAC oracle database, a single instance accesses a single database. And we know that clustering is the task of assigning a set of objects into groups. In an Oracle RAC atmosphere, two or more computers (each with an instance) simultaneously access a single database. This allows an application or user to connect to either computer and have access to a single synchronized set of data. Real Application Clusters offers significant benefits for all system types.

Definition

Real Application Clusters is a network computing solution that allows several nodes (servers) in a clustered system that is present in on shared disk storage. If a single system (node) fails, the service will still be available on the other remaining nodes. Other computers in a network access are not interrupted. All instances can simultaneously execute transactions against the single database. It is an integral part of the Oracle database setup. Oracle Real Application Clusters, or Oracle RAC is a clustering technology that provides the facility to measure performance and recover server availability for Oracle data center environments. However, getting started with Oracle RAC can be difficult and challenging for the Oracle professional who is new to this technology and has worked only with single-instance Oracle databases.

Background

Oracle 11g Clusterware is Oracle’s implementation of cluster management software, which was introduced in the 10g release of Oracle RAC software. It was originally called Cluster Ready Services (CRS) and is the complex software that exists under the hood of all Oracle 11g RAC environments. Oracle Clusterware provides several key services essential to an Oracle 11g RAC configuration, including the following:

•  Group Services to manage cluster services within 11g RAC
• Node Monitor or the “heartbeat” to monitor the status of nodes in 11g RAC cluster
• Locking services performed by the LMS database process to manage concurrency activities for 11g RAC cluster
• HA Resource management for failover or load-balancing activities in 11g RAC

Oracle has had clustering functionality in their product for a long time.  Previously, the clustering technology was more dependent on the Operating System. Oracle chose to incorporate more of the clustering functionality into the Oracle database rather than rely on how the OS does clustering.  Oracle 9i and 10g RAC have more of the key clustering capabilities within Oracle itself.  This means that the clustering is done differently than it was with Oracle Parallel Server(OPS).

Understanding

Oracle RAC is “Shared Everything” clustering.  This allows all nodes in the cluster to have access to the data at the same time.  There is only one set of data that all of the nodes can use at all times. With Real Application Clusters, We can run multiple Oracle instances on systems in a shared disk cluster configuration or on multiple nodes of a Massively Parallel Processor (MPP) configuration. RAC manages traffic between the systems or nodes, authorizing the instances to function as a single database. The failure of a single instance will not cause widespread delays while the system recovers.

Oracle RAC has multiple database instances in comparison to a single instance Oracle database, with each cluster instance in the environment functioning separately, yet in unison with the entire cluster. At the central point of performance, bottlenecks may arise in an RAC database because all of the cluster instances must share access to the RAC database. As such, tuning the pathways to the RAC database is important to ensure a high level of performance. RAC uses a parallel processing-based architecture that shares the resources among all of the cluster nodes. Cache Fusion is the mechanism that provides throughput for the RAC database by using an algorithm to send data between cluster nodes without the previous issues caused by block disk pinging in older versions of the Oracle cluster technology, which was called Oracle Parallel Clusters (OPS).

Architecture of Oracle RAC:

Oracle RAC creates a highly available architecture. Oracle RAC is a complex mix of system, network, and database technologies.

Below figure shows an overview of Oracle RAC Database Architecture.  The figure has been shared from Oracle documentation.

Figure 1: Oracle Database with Oracle RAC Architecture.

Oracle RAC allows multiple nodes to run multiple instances of Oracle while accessing a single physical database.A cluster includes multiple interconnected computers or servers that perform. Oracle RAC uses Oracle Clusterware for the substructure to bind several servers so that they operate as a single system. An Oracle RAC Databases may have more than 100 instances and all access one database. All database instances essentially use the same interconnection. Oracle Clusterware is a convenient management solution that is combined with the Oracle Database. Oracle RAC is a distinctive technology that provides high accessibility and scalability for all application types. Usually, an Oracle RAC environment is positioned in one data hub. However, we can construct Oracle RAC on an extended distance cluster, which is a design that provides tremendously fast retrieval from a site failure and allows for all nodes.

Fig 2: Shared Everything Architecture

Real Application Clusters are designed as “Shared Everything” architecture.  This means that both server resources and storage resources are shared, with a single database image.  This is beneficial for scalability and flexibility.  However, the shared nature of all of the resources (particularly storage) makes it more important than ever to institute High Availability architecture, to avoid single points of failure.

Each node in the cluster has a different physical internet protocol address. However, users (or clients) connect to the database via a virtual database service name.  Oracle automatically balances the user load among the multiple nodes in the cluster.  The RAC database instances on the different nodes subscribe to all or some subset of database services.  This allows you to choose whether specific application clients that connect to a particular database service can connect to some or all of the database nodes.

If more nodes are added to the cluster, the CPU and memory resources of the new node are immediately made available to the rest of the cluster.  (Data does not have to be re-partitioned.)  This allows you to add nodes as you need them.

Oracle 11g RAC components

In addition to the many hardware, network, and storage components that drive the foundation of Oracle 11g RAC, we have the complex software called Clusterware that lies at the heart of the Oracle RAC architecture. Oracle 11g RAC consists of these physical devices along with the Clusterware and Automatic Storage Management (ASM) software. ASM provides the mechanism for managing storage within RAC environments and uses both a special type of instance called an ASM instance and special disk volume management in the form of ASM disks and ASM disk groups. Clusterware refers to the Oracle software layer that performs the operational tasks within the Oracle-clustered environment for RAC. In summary, the Clusterware consists of the following components for Oracle 11g RAC:

• Voting Disk(s)
• Oracle Clusterware Registry (OCR)
• Background processes that manage clusterwide operations and provide functionality for Oracle 11g RAC Database

Voting Disk: The Voting Disk provides cluster quorum administration within an Oracle 11g RAC environment and is configured on shared storage for the Oracle 11g RAC environment.

Oracle Cluster Registry: The Oracle Cluster Registry provides housekeeping tasks for maintenance of the Oracle 11g RAC Clusterware infrastructure.

Oracle 11g R1 RAC background processes: Oracle 11g RAC contains many unique background processes that perform clusterwide operational tasks and management. The majority of these background processes are integrated into the Oracle 11g Clusterware, which is special software used by Oracle to manage cluster operations for RAC environments

Conclusion

In the above discussion of Oracle RAC, we discussed how Oracle RAC manages the instances and aspects of the system architecture Oracle RAC. The article gives the conceptual idea about the Oracle RAC Database in 11g. By using a shared everything architecture, Oracle RAC allows the creation of multiple, independent Oracle instances, all sharing a single database.

Run the example against a SQL 2012 instance and you will get the idea.

DECLARE @cols AS NVARCHAR(MAX)
--===============================================================
-- BUILD THE IN STRING LIST - NEAT TRICK
--===============================================================
BEGIN
	SELECT @cols =	ISNULL(@cols + ', [', '[') 
			+ CAST([subsystem] as NVARCHAR(100))+ ']'
	  FROM [msdb].[dbo].[syssubsystems]
END

SELECT @cols

This works in SQL Server 2000, 2005, 2008, 2012.

The book aims to be a sure selection for the Associate level Oracle professionals aspiring for Professional level. The topics covered and demonstrated are in line with the Oracle University prescription for Oracle Professional certification, which justify the version updates to be advanced and not complex. The book is under publication from Packt publishers and all set for its release in May, 2012.

The OCP 1Z0-146 certification is the second milestone for the Associate level Oracle professionals. The journey from Associate to Professional level enhances your reliability and credibility with the Oracle technology, catalyzes your employability, and job effectiveness.

Apart from focusing the certification preparation, the book contains ample demonstrations and best programming practices, which can be employed in day-to-day assignments.

The book aims to cover the advanced features of PL/SQL, which are required to design and optimize the PL/SQL code. The recapitulation of PL/SQL programming and advanced features like collections, external procedures, server side result caching, implementing VPD to enforce row level security, handling large objects and SecureFiles build up a concrete platform for a PL/SQL professional. Apart from the programming, the book makes instrumental recommendations on the usage of development tool SQL Developer, employing best practices in database environments and safeguarding the vulnerable areas in PL/SQL code to avoid code injection.

The book gives a deeper insight to transform the readers from mid-level programmers to professional database designers. The advanced concepts covered through this book would surely agitate the readers to dig upon and explore more on the topics.

The book is on pre sales on Packt’s website, Amazon and all leading technical book distributors. Book details are as below:

ISBN(10): 1849687226
ISBN(13): 978-1-84968-722-5

Place your order from the below links

Buy from Packt Publishing

Buy from Amazon

Database files are normally stored in a proprietary binary format that can only be mounted by an instance of the relational database software that created them.

The purpose of the database instance is to manage and deliver the data held within the database files for the users.

Modern Relational Database Management Systems (RDBMS) provide a declarative natural language abstraction layer called SQL to query the data held within the database, and provides ACID (atomicity, consistency, isolation, durability) based transactions as a key feature and benefit over other alternatives for data storage.

This is what I found so far:

• LocalDB
• Sequences
• SQL users without Instance logins
• File Tables
• THROW statement
• Support for up to 15,000 partitions
• Columnstore indexes
• User-defined server roles
• Default schemas for a Windows NT Group
• ad-hoc query paging for SELECT statements
• Support for importing and exporting Spatial data types natively using the SSMS Import/Export utility. For those of you wondering, this is a SSMS client enhancement and in my testing export/import of spatial tables worked between two SQL 2008 R2 databases where it would error on any table containing a spatial data type using the SSMS 2008 R2 client. Thank you SQL Dev Team.

New Functions:

Still wishing for:

The topics listed below should confirm your suspicion that there is significant learning and study required to understand Exadata. Outside of the Oracle Database software (which is the same) there is a lot more complexity to operate an Exadata Machine over a tradtional database server running on Linux, UNIX, Windows. Now I know why Oracle had to change the Exadata marketing from an “appliance” to a “machine”.

I plan to update these notes once the proof of concept is complete and I fully understand all the nuances of Exadata. Until then, consider this a list of topics and source of suggested resources for further study.

Exadata Infrastructure Components

• Database Servers
• Storage Servers
• InfiniBand
• Flash Cache
• CELLBOOT USB Flash Drive

Exadata Software Components

• Oracle Automatic Storage Management (ASM)
• Oracle Real Application Clusters (RAC). Not required but sales will say it is.
• Oracle Database
• Linux Logical Volume Manager (LVM)

Connectivity

• Database Servers connect to Storage Servers using the Intelligent Database protocol (iDB) implementing the “function shipping” architecture.
• iDB use the Reliable Datagram Sockets (RDS) protocol. RDS is designed for low latency and low overhead using less significantly less CPU when compared to UDP and TCP.
• iDB is based on libskgxp.

Exadata Database Servers

• No storage devices are presented to the OS on the Exadata database servers.

Exadata Storage Servers

• Storage Indexes contain min and max values for up to eight columns.
• Storage Indexes are 1MB (default) units. Identify locations where the data is not “Reverse Index”. Best for sorted data.

Exadata Smart Scan (Offloading)

• Column Projection
• Predicate Filtering
• Storage Indexes
• Bloom Filters
• SQL Functions (most single row functions can be offloaded)
• Compression and Decompression
• Encryption/Decryption

Smart Scans not available on:

• Clustered tables
• Index Organized Tabes (IOTs)
• When ROWDEPENDENCIES is enabled

Compression Types

Basic

• Compression unit is a single Oracle block. 0% PCTFREE

OLTP (Advanced Compression)

• Compression same as basic but uses symbol table to replace repeating values. 10 % PCTFREE for updates

Hybrid Columnar Compression (Exadata Storage Only)

• QUERY LOW uses LZO compression (4x)
• QUERY HIGH uses ZLIB compression (6x)
• ARCHIVE LOW uses ZLIP compression (7x)
• ARCHIVE HIGH uses bzip2 compression (12x)

Compression should not be used on tables or partitions where data is updated due to contention.

Exadata Backup and Recovery

• RMAN incremental backups benefit from the storage servers filtering out unchanged blocks.

Recommended Reading:

• Expert Oracle Exadata
• Achieving Extreme Performance with Oracle Exadata (Osborne ORACLE Press Series)
• A Technical Overview of the Oracle Exadata Database Machine and Exadata Storage Server 
• Oracle Exadata Price List

Oracle constraints are defined as the rules to preserve the data integrity in the application. These rules are imposed on a column of a database table, so as to define the basic behavioral layer of a column of the table and check the sanctity of the data flowing into it.

The data which violates the rule, fails to pass the constraint layer and oracle raises a predefined exception. The integrity layer can be further expanded programmatically through triggers and validation subprograms as per the application requirements and standards.

Constraints establish an underlying business nature of data like its uniqueness, its references, NULL behavior or domain oriented limits. The key milestones achieved by the usage of constraints are:

• Validate NULL property of the data
• Validate uniqueness of the data
• Validate referential integrity of the data

CREATE TABLE NN_DEMO
(A NUMBER CONSTRAINT CONS_NN_DEMO_A NOT NULL);

CREATE TABLE NN_DEMO (A NUMBER NOT NULL);

CREATE TABLE NN_DEMO
(A NUMBER,
NAME VARCHAR2(100),
CONSTRAINT CONS_NN_DEMO_A NOT NULL(A))
/

CREATE TABLE UNIQUE_DEMO_COL 2 (ID NUMBER, NAME VARCHAR2(100) UNIQUE);

INSERT INTO UNIQUE_DEMO_COL VALUES(1,'Name 1');

INSERT INTO UNIQUE_DEMO_COL VALUES(2,'Name 1');

CREATE TABLE UNIQUE_DEMO (ID NUMBER, NAME VARCHAR2(100),
CONSTRAINT UN_UNIQUE_DEMO_ID UNIQUE(ID));

SELECT constraint_name, constraint_type, index_name from user_constraints
where table_name='UNIQUE_DEMO';

CREATE TABLE UNIQUE_DEMO 2 (ID NUMBER, NAME VARCHAR2(100));

CREATE UNIQUE INDEX IDX_UNIQUE_DEMO ON UNIQUE_DEMO(ID);

ALTER TABLE UNIQUE_DEMO ADD CONSTRAINT UN_UNIQUE_DEMO_ID UNIQUE(ID);

SELECT constraint_name, constraint_type, index_name from user_constraints
where table_name='UNIQUE_DEMO';

ALTER TABLE [TABLE NAME] ADD PRIMARY KEY [COLUMN NAME]

CREATE TABLE PK_DEMO_1 2 (ID NUMBER PRIMARY KEY, NAME VARCHAR2(100));

SELECT CONSTRAINT_NAME, INDEX_NAME, GENERATED
FROM USER_CONSTRAINTS
WHERE TABLE_NAME='PK_DEMO_1';

CREATE TABLE PK_DEMO_2 2 ( ID NUMBER, NAME VARCHAR2(100),
CONSTRAINT PK_ID PRIMARY KEY(ID));

SELECT CONSTRAINT_NAME, INDEX_NAME, GENERATED FROM USER_CONSTRAINTS WHERE TABLE_NAME='PK_DEMO_2';

CREATE TABLE PK_DEMO_3 (ID NUMBER, NAME VARCHAR2(100));

ALTER TABLE PK_DEMO_3 ADD PRIMARY KEY (ID); Table altered.

SELECT CONSTRAINT_NAME, INDEX_NAME, GENERATED FROM USER_CONSTRAINTS WHERE TABLE_NAME='PK_DEMO_3';

SELECT * FROM FK_PARENT;

CREATE TABLE FK_DEMO_1 (CID NUMBER REFERENCES FK_PARENT(PID));

CREATE TABLE FK_DEMO_2 (CID NUMBER REFERENCES FK_PARENT(PID));

SELECT TABLE_NAME, CONSTRAINT_NAME, R_CONSTRAINT_NAME, DELETE_RULE, GENERATED FROM USER_CONSTRAINTS WHERE TABLE_NAME IN ('FK_DEMO_1','FK_DEMO_2');

CREATE TABLE CK_DEMO_1 (ID NUMBER, NAME VARCHAR2(100), EMPLOYED VARCHAR2(1) CHECK (EMPLOYED IN ('Y','N')) );

SELECT constraint_name, search_condition, generated from user_constraints
where table_name='CK_DEMO_1';

INSERT INTO CK_DEMO_1 VALUES (1, 'JOHN','Y');

INSERT INTO CK_DEMO_1 VALUES 2 (2, 'KATE','A');

CREATE TABLE CK_DEMO_1 (ID NUMBER, NAME VARCHAR2(100), EMPLOYED VARCHAR2(1),
CONSTRAINT CK_EMPLOYED_YN CHECK (EMPLOYED IN ('Y','N')) );

CREATE OR REPLACE FUNCTION CHECK_RANGE RETURN NUMBER
IS
BEGIN
RETURN 100;
END;
CREATE TABLE CK_DEMO_FUN 2 (ID NUMBER,
NAME VARCHAR2(100), AGE NUMBER CHECK (AGE < CHECK_RANGE));
)

ALTER TABLE [TABLE NAME] DROP CONSTRAINT [CONSTRAINT NAME]

SELECT * FROM CK_DEMO_1;

ALTER TABLE CK_DEMO_1 DISABLE CONSTRAINT CK_EMPLOYED_YN;

INSERT INTO CK_DEMO_1 VALUES (3, NEL','A');

SELECT * FROM CK_DEMO_1;

ALTER TABLE CK_DEMO_1 ENABLE CONSTRAINT CK_EMPLOYED_YN;

DELETE FROM CK_DEMO_1 WHERE EMPLOYED='A';

ALTER TABLE CK_DEMO_1 ENABLE CONSTRAINT CK_EMPLOYED_YN; Table altered.

However, we take security very seriously and have performed the necessary response to protect our visitors.

At this time we have notified Google of our actions, and are waiting for Google to perform another scan to give dbanotes.com a clean bill of health.

As of Sunday, Sept. 4, 2011, if you get the following browser malware warning you may safely choose to ignore it.

What was our response to the Security Exploit ?
We rebuilt the entire dbanotes.com site from scratch. New database, new WordPress installation, new Theme installation, and a clean import of all content from backup.

If you still feel you are at risk of getting malware from visiting dbanotes.com, I encourage you to wait until Google removes the official malware warning.

Thank you for your continued support.

Regards,
dbanotes.com

Data Pivoting, one of the ways to implement and achieve above purposes, can evolve multiple views with varying combinations of columns as rows and vice versa.
Oracle supports data pivoting through Pivot aggregate operators, which can be used in SQL statements. Oracle 11g introduced two new keywords PIVOT and UNPIVOT in support of this operation. While the PIVOT operation refers to the conversion of rows into columns, UNPIVOT implies the reverse operation.

Prior to the induction of the Pivot operator, such cross tabular reports used to get generated through workaround SQLs using self joins. While it achieved the purpose in small database, it proved to be nightmare in large enterprise data warehouse database systems. Performance used to be the most cursed area where high volume of data was multi folded on self joins.

PIVOT

Pivot operator transposes an aggregated row of a table into a column. The distinct row values become the columns in the output and aggregated column value places itself under the appropriate pivoted column. The syntax of Pivot operator is as below.

Syntax explanation

• [XML] – optional clause to convert the pivoted data into XML
• PIVOT_CLAUSE uses an aggregate function on one of the column of the table. This is the data which places itself against the pivoted column accordingly.
• PIVOT_FOR_CLAUSE and PIVOT_IN_CLAUSE specify a column and its distinct values which are to be pivoted. In a transposed report, the distinct values of the pivoted column appear as the header in the output. Both are mandatory clauses, so distinct values of the column must be in hand.

Examples and illustrations

A retail firm maintains the track of customer sales in three products (Product_A, Product_B, Product_C) for the months of January, February and March. The sales data is collected for three privileged customers C1, C2 and C3.

The relational table CUST_SALES stores the data for each customer against each product in each month. The table data is as below

Now, we shall pivot the table data to give a new analytic dimension. Refer the below cases.

Case 1: Customer sales in each month for each product

PRODUCT_ID column of the CUST_SALES table has been pivoted in the below query. Now observe the beauty and intelligence of Pivot operator; it retains the positions of remaining columns (i.e. CUSTOMER_ID and MONTH) and formats the sales data in accordance with the pivoted column. Also note that the PRODUCT_ID is no more a column but its distinct values i.e. Prod A, Prod B,

Prod C are transposed as the column header in the query output.

In the above query, note the aggregated function, FOR clause and IN clause of Pivot operator.

Now, check the Explain Plan of the pivot query.

The plan generated shows the pivot specific optimization of the SQL query in HASH GROUP BY function.

Case 2: Customer sales for each product in each month

Now, changing the angle of perception by replacing PRODUCT_ID with the MONTH at the header level. Distinct values of MONTH appear as column in the query output.

In the query, note that if the value(s) of the pivoted column had to have a customized title for better readability, the same can be specified using “AS” keyword. In the CUST_SALES table, abbreviated values of the MONTH column have been replaced with their complete names.

Similarly, if MONTH column has to be made as key analysis column, CUSTOMER can be raised to column header. Sales data would automatically find its place in the new matrix.

UNPIVOT

Unpivot operator functions just at the opposite principle of Pivot. Very rare occasions exist when an element is created along with its anti counterpart. Unpivot brings data in pivoted form back to the normal form. Its syntax and usage is same as that of Pivot.
Syntax

Here, UNPIVOT_CLAUSE is not an aggregated column, but an arbitrary column name, which appears in the query to accommodate the values of unpivoted columns.
UNPIVOT_FOR_CLAUSE is also an arbitrary column name to hold the unpivoted columns values.
UNPIVOT_IN_CLAUSE defines the distinct values of the columns to be unpivoted.

Illustration

CUST_SALES_MONTH is the table which holds the data in binary format, to denote whether a product has been consumed by a customer in a specific month or not. It looks more like a spreadsheet.

Now, Unpivot operator can be used here to break the CUST_SALES_MONTH table into rows to show only CUSTOMER_ID, PRODUCT_ID, MONTH and its corresponding sales. Check the query below:

Now observe the output.

For each customer and product, the „month‟ column is repetitive to list the corresponding „month_count‟ value. The UNPIVOT_FOR_CLAUSE and UNPIVOT_IN_CLAUSE are responsible to have columns of the table listed as value under MONTH column.

The UNPIVOT_CLAUSE (here, MONTH_COUNT) specifies fetches the corresponding value of the unpivoted column and places at correct position alongside its customer_id, product_id and month. This demonstrates the power intelligence of UNPIVOT operator.

The explain plan for the above query shows the UNPIVOT operation for the conversion of column headers as row values.

Applications of Pivoting

We have already seen the benefits of Pivot operator. On need basis, data can be pivoted in the required format. Still, from developers perspective, I would mention an application derived from the previous ones.

Conversion of columns to rows and vice versa.

For example, you have a test data of known values, which is required in rows. One way is to combine all the separate SELECT statements using UNION operator as below:

Unpivot operator eases this overhead in efficient and simple way. Check the query below.

Conclusion

Pivot and Unpivot have made an impactful entry into the SQL language. They have set aside the cumbersome work around solutions and efficiently transpose the data of a relational table.