{"id":1605,"date":"2020-11-21T19:43:13","date_gmt":"2020-11-21T17:43:13","guid":{"rendered":"https:\/\/blog.sqlora.com\/en\/?page_id=1605"},"modified":"2020-11-21T19:54:55","modified_gmt":"2020-11-21T17:54:55","slug":"downloads","status":"publish","type":"page","link":"https:\/\/blog.sqlora.com\/en\/downloads\/","title":{"rendered":"Presentations"},"content":{"rendered":"\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/sql-macros-game-changing-feature-for-sql-developers\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdf_macros.png\" alt=\"\" class=\"wp-image-1615\" width=\"176\" height=\"92\" srcset=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdf_macros.png 703w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdf_macros-300x157.png 300w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdf_macros-624x328.png 624w\" sizes=\"auto, (max-width: 176px) 100vw, 176px\" \/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\" (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/sql-macros-game-changing-feature-for-sql-developers\" target=\"_blank\"><strong>SQL Macros &#8211; Game Changing Feature for SQL Developers?<\/strong><\/a><\/p>\n\n\n\n<p><a rel=\"noreferrer noopener\" href=\"https:\/\/www.doag.org\" target=\"_blank\">#DOAG2020<\/a><\/p>\n\n\n\n<p>The fear of complex, hard-to-read SQL queries often leads developers to break them down using countless PL\/SQL functions. Sounds familiar and like best practice for you?  However, you often have significant performance drops caused by well-known context switches between SQL and PL\/SQL.  Even worse: the business logic hidden in PL\/SQL functions remains invisible to the Query Optimizer!<br>With SQL Macros &#8211; a new feature in Oracle 20c &#8211; the developer no longer  has to make the difficult choice between modular, clear code and good  performance.  The idea behind the new PL\/SQL functions is that they are  not executed at runtime (no context switch!),  but return SQL snippets  that are incorporated into the main query just before parsing.  This  allows to encapsulate the logic while remaining fully transparent to the  optimizer.  <\/p>\n\n\n\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/polymorphic-table-functions-in-18c-235642669\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/ptf.png\" alt=\"\" class=\"wp-image-1622\" width=\"175\" height=\"79\" srcset=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/ptf.png 699w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/ptf-300x135.png 300w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/ptf-624x280.png 624w\" sizes=\"auto, (max-width: 175px) 100vw, 175px\" \/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\"Polymorphic Table Functions in 18c (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/polymorphic-table-functions-in-18c-235642669\" target=\"_blank\"><strong>Polymorphic Table Functions in 18c<\/strong><\/a><\/p>\n\n\n\n<p><a rel=\"noreferrer noopener\" href=\"https:\/\/www.doag.org\" target=\"_blank\">#DOAG2018<\/a><\/p>\n\n\n\n<p>SQL has many powerful techniques to analyze your data right out of the box, but remains extensible even if you&#8217;re missing something.  In Oracle 18c, you can do it much easier with polymorphic table functions (PTF).  As an evolution of table functions, PTF is called in the FROM clause and is capable to encapsulate the custom processing of the input data, whereas the type of the input row need not be known at design time and the type of the output row may be determined at runtime based on the actual PTF invocation parameters.  <br>Based on simple examples, this session will give you an introduction to the main concepts and the infrastructure behind the PTF. Discover how you can develop your own flexible and self-describing extensions while focusing on business logic and leaving complex things like parallel execution to the database.<\/p>\n\n\n\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/online-statistics-gathering-for-etl\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/osgetl.png\" alt=\"\" class=\"wp-image-1627\" width=\"170\" height=\"82\" srcset=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/osgetl.png 678w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/osgetl-300x146.png 300w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/osgetl-624x303.png 624w\" sizes=\"auto, (max-width: 170px) 100vw, 170px\" \/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\"Online Statistics Gathering for ETL (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/online-statistics-gathering-for-etl\" target=\"_blank\"><strong>Online Statistics Gathering for ETL<\/strong><\/a><\/p>\n\n\n\n<p><a rel=\"noreferrer noopener\" href=\"https:\/\/www.doag.org\" target=\"_blank\">#DOAG2018<\/a><\/p>\n\n\n\n<p>Online Statistics Gathering for Bulk Loads &#8211; the official name of the feature &#8211; was introduced in Oracle 12.1. The idea is to gather optimizer statistics &#8220;on the fly&#8221; for direct path loads. Sounds good for ETL?  In certain scenarios it makes sense but even then there are many points to consider so that it becomes a reliable part of your ETL processes.  When exactly will it be working and when  not?  Do you prevent it yourself? Documented, undocumented cases, known bugs. Which statistics are gathered and which are not? What has to be considered with partitioned tables? Interval partitioning &#8211; special case? <\/p>\n\n\n<script async src=\"\/\/pagead2.googlesyndication.com\/pagead\/js\/adsbygoogle.js?client=ca-pub-2925154690547867\" crossorigin=\"anonymous\"><\/script><ins class=\"adsbygoogle\" style=\"display:block;\" data-ad-client=\"ca-pub-2925154690547867\" \ndata-ad-slot=\"7127146010\" \ndata-ad-layout-key=\"-5i+c7+4-53+hl\"\ndata-ad-format=\"fluid\"><\/ins>\n<script> \n(adsbygoogle = window.adsbygoogle || []).push({}); \n<\/script>\n\n\n\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/properly-use-parallel-dml-for-etl\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdml.png\" alt=\"\" class=\"wp-image-1629\" width=\"177\" height=\"98\" srcset=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdml.png 707w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdml-300x165.png 300w, https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/pdml-624x344.png 624w\" sizes=\"auto, (max-width: 177px) 100vw, 177px\" \/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\"Properly Use Parallel DML for ETL (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/properly-use-parallel-dml-for-etl\" target=\"_blank\"><strong>Properly Use Parallel DML for ETL<\/strong><\/a><\/p>\n\n\n\n<p><a rel=\"noreferrer noopener\" href=\"https:\/\/www.doag.org\" target=\"_blank\">#DOAG2019<\/a><\/p>\n\n\n\n<p>It is no secret that for high-performance ETL processes, not only queries but also write operations should be parallelized.  But when you make use of it, is it simply &#8220;switch on and forget&#8221;? What do you have to consider? Can it also have negative effects?  After a short reminder on how it works (including space management methods), some patterns are presented that have been noticed in several ETL review and tuning projects and help to find the answers to the following questions:  What is the interaction between PDML and partitioning of the target table? Can PDML lead to increased fragmentation of the tablespace? Can you control it? How does the Hint PQ_DISTRIBUTE help? <\/p>\n\n\n\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/merge-sql-statement-lesser-known-facets\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/merge.png\" alt=\"\" class=\"wp-image-1632\" width=\"177\" height=\"98\"\/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\"MERGE SQL Statement: Lesser Known Facets (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/merge-sql-statement-lesser-known-facets\" target=\"_blank\"><strong>MERGE SQL Statement: Lesser Known Facets<\/strong><\/a><\/p>\n\n\n\n<p><a rel=\"noreferrer noopener\" href=\"https:\/\/www.doag.org\" target=\"_blank\">#DOAG2019<\/a><\/p>\n\n\n\n<p>Introduced in Oracle 9i, the MERGE SQL statement is definitely no longer a new feature. But sometimes its behavior cannot be simply deduced from the knowledge about INSERT and UPDATE. There are some special cases which should be considered.<br>In this presentation some less known facets will be highlighted, for example: <\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>How does a MERGE behave with regarding write consistency and what write consistency is all about. What are statement restarts?<\/li><li>What is ORA-30926? Why does it take much longer if this error occurs?<\/li><li>I am not allowed to update a column that was used in ON condition (ORA-38104) What if I have to?<\/li><li>Parallel DML, Direct Path Loads: what do I have to consider?<\/li><\/ul>\n\n\n<script async src=\"\/\/pagead2.googlesyndication.com\/pagead\/js\/adsbygoogle.js?client=ca-pub-2925154690547867\" crossorigin=\"anonymous\"><\/script><ins class=\"adsbygoogle\" style=\"display:block; text-align:center;\" data-ad-client=\"ca-pub-2925154690547867\" \ndata-ad-slot=\"2727403138\" \ndata-ad-layout=\"in-article\"\ndata-ad-format=\"fluid\"><\/ins>\n<script> \n(adsbygoogle = window.adsbygoogle || []).push({}); \n<\/script>\n\n\n\n<p><\/p>\n\n\n\n<div class=\"wp-block-image\"><figure class=\"alignleft is-resized\"><a href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/sql-pattern-matching-should-i-start-using-it\" target=\"_blank\" rel=\"noreferrer noopener\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/blog.sqlora.com\/en\/wp-content\/uploads\/sites\/2\/2020\/11\/mr.png\" alt=\"\" class=\"wp-image-1634\" width=\"177\" height=\"98\"\/><\/a><\/figure><\/div>\n\n\n\n<p><a rel=\"noreferrer noopener\" aria-label=\"SQL Pattern Matching \u2013 should I start using it? (opens in a new tab)\" href=\"https:\/\/www2.slideshare.net\/AndrejPashchenko\/sql-pattern-matching-should-i-start-using-it\" target=\"_blank\"><strong>SQL Pattern Matching \u2013 should I start using it?<\/strong><\/a><\/p>\n\n\n\n<p><a href=\"https:\/\/www.doag.org\" target=\"_blank\" rel=\"noreferrer noopener\" aria-label=\"#DOAG2015 (opens in a new tab)\">#DOAG2015<\/a><\/p>\n\n\n\n<p>Introduced in Oracle Database 12c, the new MATCH_RECOGNIZE clause allows pattern matching across rows and is often associated with Big Data, complex event processing, etc. Should SQL developers who are not (yet) faced with such tasks ignore it? No way! The new feature is powerful enough to simplify a lot of day-to-day tasks and to solve them in a new, simple and efficient way. The insight into a new syntax is given based on common examples, as finding gaps, merging temporal intervals or grouping on fuzzy criteria.  Providing more straightforward approach for solving known problems, the new functionality is worth to be a part of every developer\u2019s toolbox.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>SQL Macros &#8211; Game Changing Feature for SQL Developers? #DOAG2020 The fear of complex, hard-to-read SQL queries often leads developers to break them down using countless PL\/SQL functions. Sounds familiar and like best practice for you? However, you often have significant performance drops caused by well-known context switches between SQL and PL\/SQL. Even worse: the [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1605","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/pages\/1605","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/comments?post=1605"}],"version-history":[{"count":19,"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/pages\/1605\/revisions"}],"predecessor-version":[{"id":1644,"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/pages\/1605\/revisions\/1644"}],"wp:attachment":[{"href":"https:\/\/blog.sqlora.com\/en\/wp-json\/wp\/v2\/media?parent=1605"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}