{"id":8276,"date":"2018-05-06T12:22:59","date_gmt":"2018-05-06T10:22:59","guid":{"rendered":"https:\/\/www.salvis.com\/blog\/?p=8276"},"modified":"2023-11-08T01:36:39","modified_gmt":"2023-11-08T00:36:39","slug":"why-and-how-using-the-accessible_by_clause","status":"publish","type":"post","link":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/","title":{"rendered":"Why and How Using the accessible_by_clause"},"content":{"rendered":"\n

The accessible_by_clause<\/code> was introduced in Oracle Database 12 Release 1 and extended in Release 2. If you don\u2018t know this feature, I suggest having a look at the documentation or reading Steven Feuerstein’s blog post<\/a>.<\/p>\n\n\n\n

In this blog post, I talk about how to use this feature properly.<\/p>\n\n\n\n

Consider you have a schema the_api<\/code> and there’s a package math<\/code> with the following signature:<\/p>\n\n\n\n

1) package math<\/span><\/path><\/path><\/svg><\/span>
CREATE OR REPLACE<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.math<\/span> <\/span>AS<\/span><\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the sum of all integers found in a string.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers string containing integers to be summarized<\/span><\/span>\n   * @returns sum, NULL if no integers are found<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the digit sum of an integer.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integer input integer to calculate cross sum from <\/span><\/span>\n   * @returns cross sum, NULL if input is NULL<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_cross_sum<\/span>(<\/span><\/span>\n      in_integer <\/span>IN<\/span> <\/span>INTEGER<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\nEND<\/span> math;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The next query uses the provided functions get_sum<\/code> and get_cross_sum<\/code>:<\/p>\n\n\n\n
2) using functions in package math<\/span><\/path><\/path><\/svg><\/span>
SELECT<\/span> the_api.math.get_sum(<\/span>'What is the sum of 5, 7, 13 and 17?'<\/span>) <\/span>AS<\/span> the_sum,<\/span><\/span>\n       the_api.math.get_cross_sum(<\/span>3456789<\/span>) <\/span>AS<\/span> the_cross_sum<\/span><\/span>\n  <\/span>FROM<\/span> dual;<\/span><\/span>\n<\/span>\n   THE_SUM THE_CROSS_SUM<\/span><\/span>\n---------- -------------<\/span><\/span>\n        <\/span>42<\/span>            <\/span>42<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
No accessible_by_clause<\/code><\/h2>\n\n\n\n
In an Oracle Database 11g the package body might be implemented like this:<\/p>\n\n\n\n
3) package body math<\/span><\/path><\/path><\/svg><\/span>
CREATE OR REPLACE<\/span> <\/span>PACKAGE BODY<\/span> <\/span>the_api.math<\/span> <\/span>AS<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> sys.ora_mining_number_nt<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n      <\/span>l_result<\/span> <\/span>INTEGER<\/span>;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>SELECT<\/span> <\/span>sum<\/span>(column_value)<\/span><\/span>\n        <\/span>INTO<\/span> <\/span>l_result<\/span><\/span>\n        <\/span>FROM<\/span> <\/span>table<\/span>(in_integers);<\/span><\/span>\n      <\/span>RETURN<\/span> <\/span>l_result<\/span>;<\/span><\/span>\n   <\/span>END<\/span> get_sum;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>to_int_table<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span>,<\/span><\/span>\n      in_pattern  <\/span>IN<\/span> <\/span>VARCHAR2<\/span> <\/span>DEFAULT<\/span> <\/span>'[0-9]+'<\/span><\/span>\n   ) <\/span>RETURN<\/span> sys.ora_mining_number_nt <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n      <\/span>l_result<\/span> sys.ora_mining_number_nt := sys.ora_mining_number_nt();<\/span><\/span>\n      <\/span>l_pos<\/span>    <\/span>INTEGER<\/span> := <\/span>1<\/span>;<\/span><\/span>\n      <\/span>l_int<\/span>    <\/span>INTEGER<\/span>;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <<integer_tokens>><\/span><\/span>\n      <\/span>LOOP<\/span><\/span>\n         <\/span>l_int<\/span> := <\/span>to_number<\/span>(regexp_substr(in_integers, in_pattern, <\/span>1<\/span>, <\/span>l_pos<\/span>));<\/span><\/span>\n         <\/span>EXIT<\/span> integer_tokens <\/span>WHEN<\/span> <\/span>l_int<\/span> <\/span>IS NULL<\/span>;<\/span><\/span>\n         <\/span>l_result<\/span>.EXTEND<\/span>;<\/span><\/span>\n         <\/span>l_result<\/span>(<\/span>l_pos<\/span>) := <\/span>l_int<\/span>;<\/span><\/span>\n         <\/span>l_pos<\/span> := <\/span>l_pos<\/span> + <\/span>1<\/span>;<\/span><\/span>\n      <\/span>END LOOP<\/span> integer_tokens;<\/span><\/span>\n      <\/span>RETURN<\/span> <\/span>l_result<\/span>;<\/span><\/span>\n   <\/span>END<\/span> to_int_table;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>RETURN<\/span> get_sum(to_int_table(in_integers));<\/span><\/span>\n   <\/span>END<\/span> get_sum;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_cross_sum<\/span>(<\/span><\/span>\n      in_integer <\/span>IN<\/span> <\/span>INTEGER<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>RETURN<\/span> get_sum(to_int_table(<\/span>to_char<\/span>(in_integer), <\/span>'[0-9]'<\/span>));       <\/span><\/span>\n   <\/span>END<\/span> get_cross_sum;<\/span><\/span>\nEND<\/span> math;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The private functions get_sum<\/code> and to_int_table<\/code> are doing the real work. Here are some issues with this code<\/p>\n\n\n\n
1. Use of undocumented collection type sys.ora_mining_number_nt<\/code><\/strong><\/p>\n\n\n\n
The private functions avoid the use of their own type, something like CREATE TYPE t_integer_type IS TABLE OF INTEGER. This shortcut is hidden and not part of the API. It is not super elegant, but quite common and easy to fix when Oracle decides to remove this collection type in a future release or to protect it with an accessible_by_clause<\/code>. So I do not consider this a real problem and will not deal with it in this blog post.<\/p>\n\n\n\n
2. Private function definitions must be ordered according its usage<\/strong><\/p>\n\n\n\n
The private functions are listed at the top of the package body, hence no forward declarations are necessary. Forward declarations lead to some confusion since IDEs do not distinguish between declarations and definitions in the outline window and you often end up selecting the wrong one. However, without forward declaration you have to order your private functions according its usage, which might break your domain-specific ordering logic.<\/p>\n\n\n\n
3. Private functions are not documented<\/strong><\/p>\n\n\n\n
I usually document the signature of a PL\/SQL unit in the package specification only, that’s supported by\u00a0PLDoc<\/a>. Hence the private functions are treated like second-class citizens and left undocumented.<\/p>\n\n\n\n
4. Private functions cannot be unit-tested<\/strong><\/p>\n\n\n\n
I’m not really a testing advocate. But as a developer, I’d like to know if my code works. I have to run it somehow. Usually more than once to get a working result. Hence I create scripts or unit tests. It is not possible to unit test the private functions directly. They have to be tested through public functions get_sum<\/code> and get_cross_sum<\/code>. In this case I’d like to test the private function to_int_table<\/code> directly.<\/p>\n\n\n\n
The accessible_by_clause<\/code> can address issues 2, 3 and 4 without implicitly extending the API.<\/p>\n\n\n\n
Package-Level accessible_by_clause<\/code><\/h2>\n\n\n\n
In Oracle Database 12c Release 1, the accessible_by_clause was introduced on the package level. This allows us to move the private functions\u00a0from the package math<\/code> into a dedicated package math_internal<\/code> with restricted access.\u00a0 Here’s the refactoring result:<\/p>\n\n\n\n
4) using accessible_by_clause on package level<\/span><\/path><\/path><\/svg><\/span>
CREATE OR REPLACE<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.math_internal<\/span>  <\/span><\/span>\n   ACCESSIBLE BY (<\/span>PACKAGE<\/span> <\/span>the_api.math,<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.test_math_internal)<\/span> <\/span><\/span>\nAS<\/span><\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the sum of all integers in a collection.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers collection of integers to be summarized<\/span><\/span>\n   * @returns sum, NULL if collection is empty<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n     in_integers <\/span>IN<\/span> sys.ora_mining_number_nt<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Finds integer tokens in string.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers string containing integers to be tokenized<\/span><\/span>\n   * @param in_pattern regular expression for integers<\/span><\/span>\n   * @returns table of integers<\/span><\/span>\n   *\/<\/span><\/span>\n    <\/span>FUNCTION<\/span> <\/span>to_int_table<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span>,<\/span><\/span>\n      in_pattern  <\/span>IN<\/span> <\/span>VARCHAR2<\/span> <\/span>DEFAULT<\/span> <\/span>'[0-9]+'<\/span><\/span>\n   ) <\/span>RETURN<\/span> sys.ora_mining_number_nt <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\nEND<\/span> math_internal;<\/span><\/span>\n\/<\/span><\/span>\n<\/span>\nCREATE OR REPLACE<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.math<\/span> <\/span>AS<\/span><\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the sum of all integers found in a string.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers string containing integers to be summarized<\/span><\/span>\n   * @returns sum, NULL if no integers are found<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the digit sum of an integer.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integer input integer to calculate cross sum from <\/span><\/span>\n   * @returns cross sum, NULL if input is NULL<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_cross_sum<\/span>(<\/span><\/span>\n      in_integer <\/span>IN<\/span> <\/span>INTEGER<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\nEND<\/span> math;<\/span><\/span>\n\/<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
The accessible_by_clause<\/code> defined on line 2 restricts access to the package math<\/code>\u00a0and the package test_math_internal<\/code>.\u00a0 It is important to note that the units referenced in the accessible_by_clause<\/code> are not checked for existence when compiling PL\/SQL definitions, hence it is perfectly fine to list PL\/SQL units in the accessible_by_clause<\/code>\u00a0which might not exist in a production environment, such as the utPLSQL unit test package test_math_internal<\/code>.<\/p>\n\n\n\n
With this change, I address the previously mentioned issues 2, 3 and 4.<\/p>\n\n\n\n
    \n
  • There are no private functions anymore, hence the order in the code is irrelevant<\/li>\n\n\n\n
  • All functions are documented<\/li>\n\n\n\n
  • All functions can be unit-tested<\/li>\n<\/ul>\n\n\n\n
    Looks good, right? Yes and no. This change created some new issues.<\/p>\n\n\n\n
    5. Splitting code that belongs together<\/strong><\/p>\n\n\n\n
    The original math<\/code> the package was reasonably small and contained the whole processing logic. Now the package is divided into two packages and the code is spread into 4 files in the VCS (2 package specification files and 2 package body files).\u00a0 This accessiblity_clause is driving my PL\/SQL code structure. This might be good in some cases, but in this case, I do not like it.<\/p>\n\n\n\n
    6. Accessibility per package leads to more code splitting<\/strong><\/p>\n\n\n\n
    Remember I just wanted to unit-test the function to_int_table. Now I can also unit-test the function get_sum<\/code> since it is defined in the same package. It would look incomplete, if my unit tests would not cover get_sum<\/code>, right? So, if I want to express that get_sum<\/code> does not need an explicit unit test, I have to split the package math_internal<\/code> further. For example into math_internal1<\/code> and math_internal2<\/code> and only the one containing the function to_int_table<\/code> will have an accessor for the test package. This clearly shows that the granularity of the accessible_by_clause<\/code> is too coarse-grained.<\/p>\n\n\n\n
    \u00a0We can address these issues with an accessible_by_clause<\/code> on the unit level.<\/p>\n\n\n\n
    Unit-Level accessible_by_clause<\/code><\/h2>\n\n\n\n
    Since Oracle Database 12c Release 2 the accessible_by_clause<\/code> can be defined per package suprogram. This allows us to keep all subprograms in one package while addressing all previously described issues. Here’s the refactoring result:<\/p>\n\n\n\n
    5) using accessible_by_clause on unit level (specification)<\/span><\/path><\/path><\/svg><\/span>
    CREATE OR REPLACE<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.math<\/span> <\/span>AS<\/span><\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the sum of all integers found in a string.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers string containing integers to be summarized<\/span><\/span>\n   * @returns sum, NULL if no integers are found<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the digit sum of an integer.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integer input integer to calculate cross sum from <\/span><\/span>\n   * @returns cross sum, NULL if input is NULL<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_cross_sum<\/span>(<\/span><\/span>\n      in_integer <\/span>IN<\/span> <\/span>INTEGER<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Calculates the sum of all integers in a collection.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers collection of integers to be summarized<\/span><\/span>\n   * @returns sum, NULL if collection is empty<\/span><\/span>\n   *\/<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n     in_integers <\/span>IN<\/span> sys.ora_mining_number_nt<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span><\/span>\n   ACCESSIBLE BY (<\/span>PACKAGE<\/span> <\/span>the_api.math);<\/span><\/span>\n<\/span>\n   <\/span>\/**<\/span><\/span>\n   * Finds integer tokens in string.<\/span><\/span>\n   *<\/span><\/span>\n   * @param in_integers string containing integers to be tokenized<\/span><\/span>\n   * @param in_pattern regular expression for integers<\/span><\/span>\n   * @returns table of integers<\/span><\/span>\n   *\/<\/span><\/span>\n    <\/span>FUNCTION<\/span> <\/span>to_int_table<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span>,<\/span><\/span>\n      in_pattern  <\/span>IN<\/span> <\/span>VARCHAR2<\/span> <\/span>DEFAULT<\/span> <\/span>'[0-9]+'<\/span><\/span>\n   ) <\/span>RETURN<\/span> sys.ora_mining_number_nt <\/span>DETERMINISTIC<\/span><\/span>\n   ACCESSIBLE BY (<\/span>PACKAGE<\/span> <\/span>the_api.math,<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.test_math);<\/span><\/span>\nEND<\/span> math;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    On line 31 the access to the overloaded function get_sum<\/code> is restricted to this package. It’s semantically clear that this function cannot be unit-tested. On line 44 access to the function to_int_table is restricted to this package and the package test_math. Hence it is possible to unit-test this function in the package test_math.\u00a0 The package math is not split up and the access to the original private functions is properly protected.<\/p>\n\n\n\n
    The package body looks quite similar to the original one. I’ve just put the access-restricted units at the bottom, to match the order and the signature in the specification.<\/p>\n\n\n\n
    6) using accessible_by_clause on unit level (body)<\/span><\/path><\/path><\/svg><\/span>
    CREATE OR REPLACE<\/span> <\/span>PACKAGE BODY<\/span> <\/span>the_api.math<\/span> <\/span>AS<\/span><\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span>) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>RETURN<\/span> math.get_sum(math.to_int_table(in_integers));<\/span><\/span>\n   <\/span>END<\/span> get_sum;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_cross_sum<\/span>(in_integer <\/span>IN<\/span> <\/span>INTEGER<\/span>) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>RETURN<\/span> math.get_sum(math.to_int_table(<\/span>to_char<\/span>(in_integer), <\/span>'[0-9]'<\/span>));       <\/span><\/span>\n   <\/span>END<\/span> get_cross_sum;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>get_sum<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> sys.ora_mining_number_nt<\/span><\/span>\n   ) <\/span>RETURN<\/span> <\/span>INTEGER<\/span> <\/span>DETERMINISTIC<\/span><\/span>\n      ACCESSIBLE BY (<\/span>PACKAGE<\/span> <\/span>the_api.math)<\/span><\/span>\n   <\/span>IS<\/span><\/span>\n      <\/span>l_result<\/span> <\/span>INTEGER<\/span>;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>SELECT<\/span> <\/span>sum<\/span>(column_value)<\/span><\/span>\n        <\/span>INTO<\/span> <\/span>l_result<\/span><\/span>\n        <\/span>FROM<\/span> <\/span>table<\/span>(in_integers);<\/span><\/span>\n      <\/span>RETURN<\/span> <\/span>l_result<\/span>;<\/span><\/span>\n   <\/span>END<\/span> get_sum;<\/span><\/span>\n<\/span>\n   <\/span>FUNCTION<\/span> <\/span>to_int_table<\/span>(<\/span><\/span>\n      in_integers <\/span>IN<\/span> <\/span>VARCHAR2<\/span>,<\/span><\/span>\n      in_pattern  <\/span>IN<\/span> <\/span>VARCHAR2<\/span> <\/span>DEFAULT<\/span> <\/span>'[0-9]+'<\/span><\/span>\n   ) <\/span>RETURN<\/span> sys.ora_mining_number_nt <\/span>DETERMINISTIC<\/span> <\/span><\/span>\n      ACCESSIBLE BY (<\/span>PACKAGE<\/span> <\/span>the_api.math,<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.test_math)<\/span><\/span>\n   <\/span>IS<\/span><\/span>\n      <\/span>l_result<\/span> sys.ora_mining_number_nt := sys.ora_mining_number_nt();<\/span><\/span>\n      <\/span>l_pos<\/span>    <\/span>INTEGER<\/span> := <\/span>1<\/span>;<\/span><\/span>\n      <\/span>l_int<\/span>    <\/span>INTEGER<\/span>;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <<integer_tokens>><\/span><\/span>\n      <\/span>LOOP<\/span><\/span>\n         <\/span>l_int<\/span> := <\/span>to_number<\/span>(regexp_substr(in_integers, in_pattern, <\/span>1<\/span>, <\/span>l_pos<\/span>));<\/span><\/span>\n         <\/span>EXIT<\/span> integer_tokens <\/span>WHEN<\/span> <\/span>l_int<\/span> <\/span>IS NULL<\/span>;<\/span><\/span>\n         <\/span>l_result<\/span>.EXTEND<\/span>;<\/span><\/span>\n         <\/span>l_result<\/span>(<\/span>l_pos<\/span>) := <\/span>l_int<\/span>;<\/span><\/span>\n         <\/span>l_pos<\/span> := <\/span>l_pos<\/span> + <\/span>1<\/span>;<\/span><\/span>\n      <\/span>END LOOP<\/span> integer_tokens;<\/span><\/span>\n      <\/span>RETURN<\/span> <\/span>l_result<\/span>;<\/span><\/span>\n   <\/span>END<\/span> to_int_table;<\/span><\/span>\nEND<\/span> math;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Taking about unit testing without showing a unit test is a bit inauthentic. So, here is the utPLSQL test package:<\/p>\n\n\n\n
    7) utPLSQL unit tests<\/span><\/path><\/path><\/svg><\/span>
    CREATE OR REPLACE<\/span> <\/span>PACKAGE<\/span> <\/span>the_api.test_math<\/span> <\/span>IS<\/span><\/span>\n   <\/span>--%suite<\/span><\/span>\n<\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_sum_1<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_sum_2<\/span>;<\/span><\/span>\n <\/span><\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_cross_sum_1<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_cross_sum_2<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>to_int_table_1<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>--%test<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>to_int_table_2<\/span>;<\/span><\/span>\nEND<\/span> test_math;<\/span><\/span>\n\/<\/span><\/span>\n<\/span>\nCREATE OR REPLACE<\/span> <\/span>PACKAGE BODY<\/span> <\/span>the_api.test_math<\/span> <\/span>IS<\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_sum_1<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      ut.expect(<\/span>42<\/span>).to_equal(the_api.math.get_sum(<\/span>'What is the sum of 5, 7, 13 and 17?'<\/span>));<\/span><\/span>\n   <\/span>END<\/span> get_sum_1;<\/span><\/span>\n   <\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_sum_2<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      ut.expect(<\/span>CAST<\/span>(<\/span>NULL<\/span> <\/span>AS<\/span> <\/span>INTEGER<\/span>)).to_equal(the_api.math.get_sum(<\/span>'What is the sum?'<\/span>));<\/span><\/span>\n   <\/span>END<\/span> get_sum_2; <\/span><\/span>\n<\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_cross_sum_1<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      ut.expect(<\/span>42<\/span>).to_equal(the_api.math.get_cross_sum(<\/span>3456789<\/span>));<\/span><\/span>\n   <\/span>END<\/span> get_cross_sum_1;<\/span><\/span>\n   <\/span><\/span>\n   <\/span>PROCEDURE<\/span> <\/span>get_cross_sum_2<\/span> <\/span>IS<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      ut.expect(<\/span>CAST<\/span>(<\/span>NULL<\/span> <\/span>AS<\/span> <\/span>INTEGER<\/span>)).to_equal(the_api.math.get_cross_sum(<\/span>NULL<\/span>));<\/span><\/span>\n   <\/span>END<\/span> get_cross_sum_2;<\/span><\/span>\n<\/span>\n   <\/span>PROCEDURE<\/span> <\/span>to_int_table_1<\/span> <\/span>IS<\/span><\/span>\n      <\/span>l_expected<\/span> sys.ora_mining_number_nt;<\/span><\/span>\n      <\/span>l_actual<\/span>   sys.ora_mining_number_nt;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>l_expected<\/span> := sys.ora_mining_number_nt(<\/span>5<\/span>, <\/span>7<\/span>, <\/span>13<\/span>, <\/span>17<\/span>);<\/span><\/span>\n      <\/span>l_actual<\/span> := math.to_int_table(<\/span>'What is the sum of 5, 7, 13 and 17?'<\/span>);<\/span><\/span>\n      ut.expect(anydata.convertCollection(<\/span>l_expected<\/span>)).to_equal(anydata.convertCollection(<\/span>l_actual<\/span>));<\/span><\/span>\n   <\/span>END<\/span> to_int_table_1;<\/span><\/span>\n<\/span>\n   <\/span>PROCEDURE<\/span> <\/span>to_int_table_2<\/span> <\/span>IS<\/span><\/span>\n      <\/span>l_expected<\/span> sys.ora_mining_number_nt;<\/span><\/span>\n      <\/span>l_actual<\/span>   sys.ora_mining_number_nt;<\/span><\/span>\n   <\/span>BEGIN<\/span><\/span>\n      <\/span>l_expected<\/span> := sys.ora_mining_number_nt();<\/span><\/span>\n      <\/span>l_actual<\/span> := math.to_int_table(<\/span>NULL<\/span>);<\/span><\/span>\n      ut.expect(anydata.convertCollection(<\/span>l_expected<\/span>)).to_equal(anydata.convertCollection(<\/span>l_actual<\/span>));<\/span><\/span>\n   <\/span>END<\/span> to_int_table_2;<\/span><\/span>\nEND<\/span> test_math;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Running utPLSQL tests is easy, see:<\/p>\n\n\n\n
    8) running utPLSQL tests<\/span><\/path><\/path><\/svg><\/span>
    SET<\/span> SERVEROUTPUT <\/span>ON<\/span> SIZE UNLIMITED<\/span><\/span>\nEXECUTE ut.run(<\/span>'THE_API.TEST_MATH'<\/span>);<\/span><\/span>\n<\/span>\ntest_math<\/span><\/span>\n  get_sum_1 [.<\/span>004<\/span> sec]<\/span><\/span>\n  get_sum_2 [.<\/span>004<\/span> sec]<\/span><\/span>\n  get_cross_sum_1 [.<\/span>004<\/span> sec]<\/span><\/span>\n  get_cross_sum_2 [.<\/span>004<\/span> sec]<\/span><\/span>\n  to_int_table_1 [.<\/span>009<\/span> sec]<\/span><\/span>\n  to_int_table_2 [.<\/span>007<\/span> sec]<\/span><\/span>\n <\/span><\/span>\nFinished <\/span>in<\/span> .<\/span>034975<\/span> seconds<\/span><\/span>\n6<\/span> tests, <\/span>0<\/span> failed, <\/span>0<\/span> errored, <\/span>0<\/span> disabled, <\/span>0<\/span> warning(s)<\/span><\/span>\n <\/span><\/span>\n<\/span>\n<\/span>\nPL\/<\/span>SQL<\/span> procedure successfully completed.<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Conclusion<\/h2>\n\n\n\n
    Start using the accessible_by_clause<\/code>. But using the accessible_by_clause<\/code> should not drive the way you structure your PL\/SQL code. It certainly should not lead to a code-splitting avalanche. Hence I favour the definition of the accessible_by_clause<\/code> on the subprogram level.<\/p>\n","protected":false},"excerpt":{"rendered":"
    The accessible_by_clause was introduced in Oracle Database 12 Release 1 and extended in Release 2. If you don\u2018t know this feature, I suggest having a look at the documentation or reading Steven Feuerstein’s blog post. In this blog post, I talk about how to use this feature properly. Consider you have a [\u2026]<\/span><\/p>\n","protected":false},"author":1,"featured_media":9523,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[106,13,85,105],"class_list":["post-8276","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oracle","tag-accessible_by_clause","tag-plsql","tag-sql","tag-utplsql"],"yoast_head":"\nWhy and How Using the accessible_by_clause - Philipp Salvisberg's Blog<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Why and How Using the accessible_by_clause - Philipp Salvisberg's Blog\" \/>\n<meta property=\"og:description\" content=\"The accessible_by_clause was introduced in Oracle Database 12 Release 1 and extended in Release 2. If you don\u2018t know this feature, I suggest having a look at the documentation or reading Steven Feuerstein’s blog post. In this blog post, I talk about how to use this feature properly. Consider you have a [\u2026]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/\" \/>\n<meta property=\"og:site_name\" content=\"Philipp Salvisberg's Blog\" \/>\n<meta property=\"article:published_time\" content=\"2018-05-06T10:22:59+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-11-08T00:36:39+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png\" \/>\n\t<meta property=\"og:image:width\" content=\"574\" \/>\n\t<meta property=\"og:image:height\" content=\"453\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Philipp Salvisberg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@phsalvisberg\" \/>\n<meta name=\"twitter:site\" content=\"@phsalvisberg\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Philipp Salvisberg\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"5 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/\"},\"author\":{\"name\":\"Philipp Salvisberg\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"headline\":\"Why and How Using the accessible_by_clause\",\"datePublished\":\"2018-05-06T10:22:59+00:00\",\"dateModified\":\"2023-11-08T00:36:39+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/\"},\"wordCount\":957,\"commentCount\":3,\"publisher\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"image\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/05\\\/accessible_by_clause.png\",\"keywords\":[\"accessible_by_clause\",\"PL\\\/SQL\",\"SQL\",\"utPLSQL\"],\"articleSection\":[\"Oracle\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/\",\"name\":\"Why and How Using the accessible_by_clause - Philipp Salvisberg's Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/05\\\/accessible_by_clause.png\",\"datePublished\":\"2018-05-06T10:22:59+00:00\",\"dateModified\":\"2023-11-08T00:36:39+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/05\\\/accessible_by_clause.png\",\"contentUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2018\\\/05\\\/accessible_by_clause.png\",\"width\":574,\"height\":453},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2018\\\/05\\\/06\\\/why-and-how-using-the-accessible_by_clause\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Why and How Using the accessible_by_clause\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/\",\"name\":\"Philipp Salvisberg's Blog\",\"description\":\"Database-centric development\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\",\"name\":\"Philipp Salvisberg\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"contentUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"width\":400,\"height\":400,\"caption\":\"Philipp Salvisberg\"},\"logo\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\"},\"sameAs\":[\"http:\\\/\\\/www.salvis.com\\\/\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Why and How Using the accessible_by_clause - Philipp Salvisberg's Blog","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/","og_locale":"en_US","og_type":"article","og_title":"Why and How Using the accessible_by_clause - Philipp Salvisberg's Blog","og_description":"The accessible_by_clause was introduced in Oracle Database 12 Release 1 and extended in Release 2. If you don\u2018t know this feature, I suggest having a look at the documentation or reading Steven Feuerstein’s blog post. In this blog post, I talk about how to use this feature properly. Consider you have a [\u2026]","og_url":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/","og_site_name":"Philipp Salvisberg's Blog","article_published_time":"2018-05-06T10:22:59+00:00","article_modified_time":"2023-11-08T00:36:39+00:00","og_image":[{"width":574,"height":453,"url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png","type":"image\/png"}],"author":"Philipp Salvisberg","twitter_card":"summary_large_image","twitter_creator":"@phsalvisberg","twitter_site":"@phsalvisberg","twitter_misc":{"Written by":"Philipp Salvisberg","Est. reading time":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#article","isPartOf":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/"},"author":{"name":"Philipp Salvisberg","@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"headline":"Why and How Using the accessible_by_clause","datePublished":"2018-05-06T10:22:59+00:00","dateModified":"2023-11-08T00:36:39+00:00","mainEntityOfPage":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/"},"wordCount":957,"commentCount":3,"publisher":{"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"image":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#primaryimage"},"thumbnailUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png","keywords":["accessible_by_clause","PL\/SQL","SQL","utPLSQL"],"articleSection":["Oracle"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/","url":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/","name":"Why and How Using the accessible_by_clause - Philipp Salvisberg's Blog","isPartOf":{"@id":"https:\/\/www.salvis.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#primaryimage"},"image":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#primaryimage"},"thumbnailUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png","datePublished":"2018-05-06T10:22:59+00:00","dateModified":"2023-11-08T00:36:39+00:00","breadcrumb":{"@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#primaryimage","url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png","contentUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2018\/05\/accessible_by_clause.png","width":574,"height":453},{"@type":"BreadcrumbList","@id":"https:\/\/www.salvis.com\/blog\/2018\/05\/06\/why-and-how-using-the-accessible_by_clause\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.salvis.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Why and How Using the accessible_by_clause"}]},{"@type":"WebSite","@id":"https:\/\/www.salvis.com\/blog\/#website","url":"https:\/\/www.salvis.com\/blog\/","name":"Philipp Salvisberg's Blog","description":"Database-centric development","publisher":{"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.salvis.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515","name":"Philipp Salvisberg","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","contentUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","width":400,"height":400,"caption":"Philipp Salvisberg"},"logo":{"@id":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg"},"sameAs":["http:\/\/www.salvis.com\/"]}]}},"_links":{"self":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/8276","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/comments?post=8276"}],"version-history":[{"count":57,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/8276\/revisions"}],"predecessor-version":[{"id":12632,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/8276\/revisions\/12632"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/media\/9523"}],"wp:attachment":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/media?parent=8276"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/categories?post=8276"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/tags?post=8276"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}