{"id":1811,"date":"2025-08-16T03:29:47","date_gmt":"2025-08-16T03:29:47","guid":{"rendered":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/"},"modified":"2025-08-16T03:29:47","modified_gmt":"2025-08-16T03:29:47","slug":"oracle-packages-organizing-pl-sql-code-for-scalability","status":"publish","type":"post","link":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/","title":{"rendered":"Oracle Packages: Organizing PL\/SQL Code for Scalability"},"content":{"rendered":"<h1>Oracle Packages: Organizing PL\/SQL Code for Scalability \ud83c\udfaf<\/h1>\n<h2>Executive Summary<\/h2>\n<p>In the realm of Oracle database development, <strong>Oracle Packages for Scalability<\/strong> are indispensable tools for crafting robust, maintainable, and scalable applications. Packages allow developers to group related PL\/SQL code into logical units, promoting modularity and reusability. This improves code organization, simplifies debugging, and enhances overall performance. This article delves into the core concepts of Oracle Packages, explores their benefits, provides practical examples, and addresses frequently asked questions. By mastering Oracle Packages, developers can significantly improve the quality and scalability of their PL\/SQL applications, ensuring they can handle growing data volumes and user loads.\u2728<\/p>\n<p>PL\/SQL code, while powerful, can quickly become unwieldy and difficult to manage in large applications. Imagine trying to find a specific function in thousands of lines of code! Oracle Packages offer a solution by providing a structured way to organize your code. This structure isn&#8217;t just about aesthetics; it&#8217;s about creating a robust and scalable architecture for your database applications.<\/p>\n<h2>Benefits of Using Packages<\/h2>\n<p>Oracle Packages provide several advantages over standalone PL\/SQL blocks. They&#8217;re like organizing your tools in a toolbox instead of scattering them around your garage. \ud83d\udee0\ufe0f<\/p>\n<ul>\n<li><strong>Modularity:<\/strong> Packages break down complex tasks into smaller, manageable modules, making code easier to understand and maintain. Think of it as dividing a large project into smaller, achievable milestones.\u2705<\/li>\n<li><strong>Reusability:<\/strong> Procedures and functions within a package can be reused across multiple applications, reducing code duplication and development time. Why write the same code multiple times when you can write it once and use it everywhere?<\/li>\n<li><strong>Information Hiding:<\/strong> Packages allow you to hide implementation details from the outside world, exposing only the necessary interface. This protects the internal workings of your code and prevents unintended dependencies. \ud83d\udee1\ufe0f<\/li>\n<li><strong>Improved Performance:<\/strong> When a package is first called, Oracle loads it into memory. Subsequent calls to the package&#8217;s procedures and functions are faster because the code is already loaded. \ud83d\udcc8<\/li>\n<li><strong>Simplified Security:<\/strong> You can grant privileges on a package rather than on individual procedures and functions, simplifying security management. This provides a centralized control point for access to your code.<\/li>\n<li><strong>Enhanced Maintainability:<\/strong> By grouping related code together, packages make it easier to locate and modify code, reducing the risk of introducing errors. Debugging becomes significantly less challenging.\ud83d\udca1<\/li>\n<\/ul>\n<h2>Creating and Using Packages<\/h2>\n<p>Creating an Oracle Package involves defining a package specification and a package body. The specification declares the public interface, while the body contains the actual implementation. Think of the specification as the &#8220;table of contents&#8221; and the body as the &#8220;chapters&#8221; of your code.<\/p>\n<p>First, let&#8217;s create a simple package to handle employee-related operations:<\/p>\n<pre><code>\n-- Package Specification\nCREATE OR REPLACE PACKAGE employee_pkg AS\n  PROCEDURE add_employee(\n    p_employee_id NUMBER,\n    p_first_name  VARCHAR2,\n    p_last_name   VARCHAR2,\n    p_salary      NUMBER\n  );\n\n  FUNCTION get_employee_salary(\n    p_employee_id NUMBER\n  ) RETURN NUMBER;\n\nEND employee_pkg;\n\/\n\n-- Package Body\nCREATE OR REPLACE PACKAGE BODY employee_pkg AS\n\n  PROCEDURE add_employee(\n    p_employee_id NUMBER,\n    p_first_name  VARCHAR2,\n    p_last_name   VARCHAR2,\n    p_salary      NUMBER\n  ) IS\n  BEGIN\n    INSERT INTO employees (employee_id, first_name, last_name, salary)\n    VALUES (p_employee_id, p_first_name, p_last_name, p_salary);\n    COMMIT;\n  END add_employee;\n\n  FUNCTION get_employee_salary(\n    p_employee_id NUMBER\n  ) RETURN NUMBER IS\n    v_salary NUMBER;\n  BEGIN\n    SELECT salary INTO v_salary\n    FROM employees\n    WHERE employee_id = p_employee_id;\n    RETURN v_salary;\n  END get_employee_salary;\n\nEND employee_pkg;\n\/\n  <\/code><\/pre>\n<p>Now, let&#8217;s break down the code:<\/p>\n<ul>\n<li>The <strong>CREATE OR REPLACE PACKAGE employee_pkg AS<\/strong> statement initiates the package specification.<\/li>\n<li>Inside the specification, <strong>PROCEDURE add_employee(&#8230;)<\/strong> and <strong>FUNCTION get_employee_salary(&#8230;) RETURN NUMBER<\/strong> declare the procedures and functions available for use outside the package.<\/li>\n<li>The <strong>CREATE OR REPLACE PACKAGE BODY employee_pkg AS<\/strong> statement defines the implementation details.<\/li>\n<li>The <strong>add_employee<\/strong> procedure inserts a new employee record into the `employees` table.<\/li>\n<li>The <strong>get_employee_salary<\/strong> function retrieves the salary of an employee based on their ID.<\/li>\n<\/ul>\n<p>To use the package:<\/p>\n<pre><code>\nBEGIN\n  employee_pkg.add_employee(1001, 'John', 'Doe', 50000);\n  DBMS_OUTPUT.PUT_LINE('Salary: ' || employee_pkg.get_employee_salary(1001));\nEND;\n\/\n  <\/code><\/pre>\n<h2>Advanced Package Features<\/h2>\n<p>Oracle Packages offer more than just basic code organization. They also include advanced features that enhance functionality and maintainability. \ud83d\ude80<\/p>\n<ul>\n<li><strong>Package Variables:<\/strong> Packages can contain variables that maintain state across multiple calls to the package&#8217;s procedures and functions. This is useful for caching data or tracking session information.<\/li>\n<li><strong>Package Constants:<\/strong> Packages can define constants that provide a central location for frequently used values. This makes it easier to update values and ensures consistency across your code.<\/li>\n<li><strong>Package Cursors:<\/strong> Packages can declare cursors that allow you to iterate through the results of a query. This is useful for processing large datasets.<\/li>\n<li><strong>Overloading:<\/strong> You can define multiple procedures or functions with the same name but different parameter lists. This allows you to provide different versions of the same functionality. \u2728<\/li>\n<li><strong>Forward Declarations:<\/strong> If a procedure or function in the package body calls another procedure or function that is defined later in the body, you need to use a forward declaration.<\/li>\n<li><strong>Pragmas:<\/strong> Pragmas are compiler directives that provide instructions to the PL\/SQL compiler. They can be used to optimize code or suppress warnings.<\/li>\n<\/ul>\n<p>Let&#8217;s explore package variables:<\/p>\n<pre><code>\nCREATE OR REPLACE PACKAGE counter_pkg AS\n  -- Package variable\n  counter NUMBER := 0;\n\n  PROCEDURE increment_counter;\n  FUNCTION get_counter RETURN NUMBER;\nEND counter_pkg;\n\/\n\nCREATE OR REPLACE PACKAGE BODY counter_pkg AS\n  PROCEDURE increment_counter IS\n  BEGIN\n    counter := counter + 1;\n  END increment_counter;\n\n  FUNCTION get_counter RETURN NUMBER IS\n  BEGIN\n    RETURN counter;\n  END get_counter;\nEND counter_pkg;\n\/\n\n-- Usage\nBEGIN\n  counter_pkg.increment_counter;\n  counter_pkg.increment_counter;\n  DBMS_OUTPUT.PUT_LINE('Counter: ' || counter_pkg.get_counter); -- Output: Counter: 2\nEND;\n\/\n  <\/code><\/pre>\n<p>In this example, the `counter` variable maintains its value between calls to the `increment_counter` procedure.<\/p>\n<h2>Best Practices for Using Packages<\/h2>\n<p>To maximize the benefits of Oracle Packages, it&#8217;s essential to follow best practices. These practices help ensure that your code is well-organized, maintainable, and scalable. \ud83d\udc4d<\/p>\n<ul>\n<li><strong>Group Related Code:<\/strong> Packages should contain procedures and functions that are logically related. This makes it easier to understand the purpose of the package and locate the code you need.<\/li>\n<li><strong>Keep Packages Small:<\/strong> Large packages can be difficult to manage. Break down large packages into smaller, more manageable units.<\/li>\n<li><strong>Use Meaningful Names:<\/strong> Use descriptive names for your packages, procedures, and functions. This makes it easier to understand the purpose of the code.<\/li>\n<li><strong>Document Your Code:<\/strong> Add comments to your code to explain what it does. This helps other developers (and yourself!) understand the code. \ud83d\udcdd<\/li>\n<li><strong>Use Error Handling:<\/strong> Implement proper error handling to prevent unexpected errors. Use `TRY&#8230;EXCEPT` blocks to catch and handle exceptions.<\/li>\n<li><strong>Test Your Code:<\/strong> Thoroughly test your code to ensure that it works as expected. Use unit tests to test individual procedures and functions.<\/li>\n<\/ul>\n<p>Here&#8217;s an example of error handling within a package:<\/p>\n<pre><code>\nCREATE OR REPLACE PACKAGE employee_pkg AS\n  PROCEDURE update_salary(p_employee_id NUMBER, p_new_salary NUMBER);\nEND employee_pkg;\n\/\n\nCREATE OR REPLACE PACKAGE BODY employee_pkg AS\n  PROCEDURE update_salary(p_employee_id NUMBER, p_new_salary NUMBER) IS\n  BEGIN\n    UPDATE employees\n    SET salary = p_new_salary\n    WHERE employee_id = p_employee_id;\n    IF SQL%ROWCOUNT = 0 THEN\n      RAISE_APPLICATION_ERROR(-20001, 'Employee not found');\n    END IF;\n    COMMIT;\n  EXCEPTION\n    WHEN OTHERS THEN\n      ROLLBACK;\n      RAISE;\n  END update_salary;\nEND employee_pkg;\n\/\n  <\/code><\/pre>\n<h2>Real-World Use Cases<\/h2>\n<p>Oracle Packages are used extensively in various industries and applications. They provide a structured way to organize and manage PL\/SQL code, making it easier to develop and maintain complex systems. \u2705<\/p>\n<ul>\n<li><strong>Banking:<\/strong> Packages can be used to manage account transactions, calculate interest, and generate reports. They provide a secure and reliable way to handle financial data.<\/li>\n<li><strong>Healthcare:<\/strong> Packages can be used to manage patient records, schedule appointments, and process insurance claims. They ensure data integrity and compliance with regulations.<\/li>\n<li><strong>E-commerce:<\/strong> Packages can be used to manage product catalogs, process orders, and track inventory. They provide a scalable and efficient way to handle high volumes of transactions.<\/li>\n<li><strong>Manufacturing:<\/strong> Packages can be used to manage production schedules, track inventory, and control equipment. They improve efficiency and reduce costs.<\/li>\n<li><strong>Telecommunications:<\/strong> Packages can be used to manage customer accounts, process billing, and monitor network performance. They ensure reliable service delivery.<\/li>\n<li><strong>Web Hosting:<\/strong> At DoHost <a href=\"https:\/\/dohost.us\">https:\/\/dohost.us<\/a>, packages can be used to automate the creation and management of user accounts, databases, and web servers. They streamline operations and improve efficiency.<\/li>\n<\/ul>\n<p>Imagine a banking application using packages to manage customer accounts. Each account operation (deposit, withdrawal, transfer) could be encapsulated in a separate procedure within the account management package. This modular approach simplifies the code, making it easier to maintain and debug. Furthermore, information hiding ensures that sensitive account data is protected from unauthorized access.<\/p>\n<h2>FAQ \u2753<\/h2>\n<h2>FAQ \u2753<\/h2>\n<ul>\n<li>\n<h3>What is the difference between a procedure and a function in a package?<\/h3>\n<p>A procedure is a block of PL\/SQL code that performs a specific task and does not necessarily return a value. A function, on the other hand, is a block of PL\/SQL code that performs a specific task and always returns a value. Functions are often used to calculate values or retrieve data, while procedures are used to perform actions or modify data.<\/p>\n<\/li>\n<li>\n<h3>How do I grant privileges on a package?<\/h3>\n<p>You can grant privileges on a package using the `GRANT` statement. For example, to grant `EXECUTE` privilege on the `employee_pkg` package to user `john`, you would use the following statement: `GRANT EXECUTE ON employee_pkg TO john;`. This allows `john` to execute the procedures and functions within the `employee_pkg` package.<\/p>\n<\/li>\n<li>\n<h3>Can I call a package from another package?<\/h3>\n<p>Yes, you can call a package from another package. This allows you to create a hierarchy of packages, where one package calls procedures and functions in another package. This promotes code reuse and modularity. Make sure to avoid circular dependencies, where package A calls package B and package B calls package A, as this can cause errors.<\/p>\n<\/li>\n<\/ul>\n<h2>Conclusion<\/h2>\n<p><strong>Oracle Packages for Scalability<\/strong> are essential for developing well-organized, maintainable, and scalable PL\/SQL applications. By grouping related code into logical units, packages promote modularity, reusability, and information hiding. They also improve performance and simplify security management. By following best practices and leveraging advanced features, developers can significantly improve the quality and scalability of their PL\/SQL applications. Mastering Oracle Packages is a crucial step in becoming a proficient Oracle database developer and building applications that can handle the demands of modern businesses. \ud83c\udfaf\u2728 By strategically implementing packages, you are ensuring the long-term health and scalability of your Oracle applications.<\/p>\n<h3>Tags<\/h3>\n<p>  Oracle Packages, PL\/SQL, Scalability, Code Organization, Database Development<\/p>\n<h3>Meta Description<\/h3>\n<p>  Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Oracle Packages: Organizing PL\/SQL Code for Scalability \ud83c\udfaf Executive Summary In the realm of Oracle database development, Oracle Packages for Scalability are indispensable tools for crafting robust, maintainable, and scalable applications. Packages allow developers to group related PL\/SQL code into logical units, promoting modularity and reusability. This improves code organization, simplifies debugging, and enhances overall [&hellip;]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6999],"tags":[351,5986,362,7000,7032,7034,7033,753,7001,768],"class_list":["post-1811","post","type-post","status-publish","format-standard","hentry","category-oracle-database","tag-code-organization","tag-database-development","tag-modular-programming","tag-oracle-database","tag-oracle-packages","tag-package-body","tag-package-specification","tag-performance-optimization","tag-pl-sql","tag-scalability"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v25.0 (Yoast SEO v25.0) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Oracle Packages: Organizing PL\/SQL Code for Scalability - Developers Heaven<\/title>\n<meta name=\"description\" content=\"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Oracle Packages: Organizing PL\/SQL Code for Scalability\" \/>\n<meta property=\"og:description\" content=\"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728\" \/>\n<meta property=\"og:url\" content=\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/\" \/>\n<meta property=\"og:site_name\" content=\"Developers Heaven\" \/>\n<meta property=\"article:published_time\" content=\"2025-08-16T03:29:47+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/via.placeholder.com\/600x400?text=Oracle+Packages+Organizing+PLSQL+Code+for+Scalability\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/\",\"url\":\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/\",\"name\":\"Oracle Packages: Organizing PL\/SQL Code for Scalability - Developers Heaven\",\"isPartOf\":{\"@id\":\"https:\/\/developers-heaven.net\/blog\/#website\"},\"datePublished\":\"2025-08-16T03:29:47+00:00\",\"author\":{\"@id\":\"\"},\"description\":\"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728\",\"breadcrumb\":{\"@id\":\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/developers-heaven.net\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Oracle Packages: Organizing PL\/SQL Code for Scalability\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/developers-heaven.net\/blog\/#website\",\"url\":\"https:\/\/developers-heaven.net\/blog\/\",\"name\":\"Developers Heaven\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/developers-heaven.net\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Oracle Packages: Organizing PL\/SQL Code for Scalability - Developers Heaven","description":"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728","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:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/","og_locale":"en_US","og_type":"article","og_title":"Oracle Packages: Organizing PL\/SQL Code for Scalability","og_description":"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728","og_url":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/","og_site_name":"Developers Heaven","article_published_time":"2025-08-16T03:29:47+00:00","og_image":[{"url":"https:\/\/via.placeholder.com\/600x400?text=Oracle+Packages+Organizing+PLSQL+Code+for+Scalability","type":"","width":"","height":""}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/","url":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/","name":"Oracle Packages: Organizing PL\/SQL Code for Scalability - Developers Heaven","isPartOf":{"@id":"https:\/\/developers-heaven.net\/blog\/#website"},"datePublished":"2025-08-16T03:29:47+00:00","author":{"@id":""},"description":"Discover how Oracle Packages enhance PL\/SQL code organization for scalability. Learn best practices, benefits, and real-world examples. Optimize your database!\u2728","breadcrumb":{"@id":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/developers-heaven.net\/blog\/oracle-packages-organizing-pl-sql-code-for-scalability\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/developers-heaven.net\/blog\/"},{"@type":"ListItem","position":2,"name":"Oracle Packages: Organizing PL\/SQL Code for Scalability"}]},{"@type":"WebSite","@id":"https:\/\/developers-heaven.net\/blog\/#website","url":"https:\/\/developers-heaven.net\/blog\/","name":"Developers Heaven","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/developers-heaven.net\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"_links":{"self":[{"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/posts\/1811","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/comments?post=1811"}],"version-history":[{"count":0,"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/posts\/1811\/revisions"}],"wp:attachment":[{"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/media?parent=1811"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/categories?post=1811"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/developers-heaven.net\/blog\/wp-json\/wp\/v2\/tags?post=1811"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}