[
  {
    "path": "dbstuff/forall-values-of.sql",
    "mechanism": "DML",
    "name": "Oracle PL/SQL Block",
    "description": "The code interacts with an Oracle database using PL/SQL anonymous blocks and standard SQL statements. It performs a bulk update operation using the FORALL construct to optimize performance when updating multiple records based on a collection of IDs. It also utilizes standard SELECT statements for data verification.",
    "databaseName": "Oracle",
    "tablesAccessed": [
      "employees"
    ],
    "operationType": [
      "READ",
      "WRITE"
    ],
    "queryPatterns": "PL/SQL FORALL bulk update with VALUES OF clause, Simple SELECT statements",
    "transactionHandling": "Implicit within the script execution context (no explicit COMMIT/ROLLBACK)",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "FORALL l_index IN VALUES OF l_employee_values\n   UPDATE employees\n      SET salary = 10000\n    WHERE employee_id = l_employees (l_index);"
  },
  {
    "path": "com.sun.j2ee.blueprints.address.ejb",
    "mechanism": "EJB",
    "name": "AddressEJB",
    "description": "The class is an abstract Entity Bean using Container-Managed Persistence (CMP). The abstract getter and setter methods correspond to persistent fields that the EJB container automatically maps to database columns and manages synchronization for.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (CMP) handles queries automatically based on field access.",
    "transactionHandling": "Container Managed Transactions (CMT) via EJB container.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getStreetName1();\npublic abstract void setStreetName1(String streetName1);"
  },
  {
    "path": "com.sun.j2ee.blueprints.address.ejb.AddressLocal",
    "mechanism": "EJB",
    "name": "Address Entity Bean",
    "description": "This interface represents the local view of an Entity Bean, which is a persistent data component in the J2EE architecture. The actual database interaction (SQL generation, connection management) is handled by the EJB Container (for Container-Managed Persistence) or the Bean implementation class (for Bean-Managed Persistence). The getters and setters defined here correspond to persistent fields in the underlying database table.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Address"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations managed by EJB container",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB context",
    "protocol": "unknown",
    "connectionInfo": "Managed by J2EE Container",
    "codeExample": "public interface AddressLocal extends javax.ejb.EJBLocalObject {\n  public String getStreetName1();\n  public void setStreetName1(String streetName1);\n  // ..."
  },
  {
    "path": "com.sun.j2ee.blueprints.address.ejb.AddressLocalHome",
    "mechanism": "EJB",
    "name": "Address Entity Bean",
    "description": "This is an EJB Entity Bean Local Home interface. In the EJB component model, 'create' methods correspond to database INSERT operations, and 'find' methods correspond to database SELECT operations. The persistence is managed by the EJB container (Container-Managed Persistence) or the bean implementation (Bean-Managed Persistence).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "ADDRESS"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Insert via create, Select via findByPrimaryKey)",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB standard",
    "protocol": "EJB 2.x",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public AddressLocal create(String streetName1, String streetName2...) throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.catalog.client.CatalogHelper",
    "mechanism": "EJB",
    "name": "CatalogLocal",
    "description": "The class integrates with the database primarily through the `CatalogLocal` Enterprise Java Bean (EJB) or alternatively via a direct `CatalogDAO` (Fast Lane pattern). The EJB approach uses a Service Locator to find the EJB Home and create a local interface reference. The DAO approach uses a Factory to obtain a DAO instance. Both paths ultimately perform READ operations against the catalog data.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Simple CRUD and search operations with pagination",
    "transactionHandling": "Managed by EJB container or DAO implementation",
    "protocol": "EJB 2.x Local Interface / JDBC (via DAO)",
    "connectionInfo": "JNDI: java:comp/env/ejb/Catalog",
    "codeExample": "ServiceLocator sl = new ServiceLocator();\nCatalogLocalHome home =(CatalogLocalHome)sl.getLocalHome(JNDINames.CATALOG_EJBHOME);\nreturn home.create();"
  },
  {
    "path": "com.sun.j2ee.blueprints.catalog.ejb",
    "mechanism": "EJB",
    "name": "CatalogLocal",
    "description": "This file is an EJB Local Interface. While it does not contain direct database code, it defines the data access contract for the Catalog component. The implementation of this interface (the Bean) is responsible for interacting with the database to retrieve Categories, Products, and Items.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Category",
      "Product",
      "Item"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "The interface implies simple CRUD read operations (get by ID) and paginated list retrieval (get items/products with start/count).",
    "transactionHandling": "Transactions are likely managed by the EJB container (CMT), though not explicitly annotated in the interface.",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public interface CatalogLocal extends EJBLocalObject {\n    public Category getCategory(String categoryID, Locale l);\n    ..."
  },
  {
    "path": "com.sun.j2ee.blueprints.contactinfo.ejb",
    "mechanism": "EJB",
    "name": "ContactInfoLocal",
    "description": "This interface represents the local view of an Entity Bean (or Session Bean wrapping an entity) managed by the EJB container. The container handles the persistence of the fields defined by the getters and setters (FamilyName, GivenName, Telephone, Email) to the underlying database.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "simple CRUD",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB specification",
    "protocol": "EJB 2.x",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface ContactInfoLocal extends javax.ejb.EJBLocalObject {\n  public String getFamilyName();\n  public void setFamilyName(String familyName);\n}"
  },
  {
    "path": "com.sun.j2ee.blueprints.contactinfo.ejb",
    "mechanism": "EJB",
    "name": "ContactInfoEJB",
    "description": "This class is an EJB 2.x Entity Bean using Container-Managed Persistence (CMP). The container manages the synchronization of the abstract accessor methods with the underlying database table. It also manages the relationship with the Address entity via Container-Managed Relationships (CMR).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container-managed CRUD operations",
    "transactionHandling": "Container-managed transactions (CMT) typically defined in deployment descriptors",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getFamilyName();\npublic abstract void setFamilyName(String familyName);"
  },
  {
    "path": "com.sun.j2ee.blueprints.contactinfo.ejb",
    "mechanism": "EJB",
    "name": "ContactInfo Entity Bean",
    "description": "This file is the Local Home interface for an Entity EJB. It defines the methods to create (INSERT) and find (SELECT) persistent ContactInfo entities managed by the EJB container.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations managed by the container (Create and Find by Primary Key).",
    "transactionHandling": "Container Managed Transactions (CMT) are typical for EJB Home interfaces.",
    "protocol": "unknown",
    "connectionInfo": "Managed by J2EE Container",
    "codeExample": "public ContactInfoLocal findByPrimaryKey(Object key) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.creditcard.ejb",
    "mechanism": "EJB",
    "name": "CreditCard Entity Bean",
    "description": "This file is an EJB Local Home interface, which defines the persistence lifecycle methods (create, find) for an Entity Bean. The actual database interaction is handled by the EJB container (Container Managed Persistence) or the bean implementation (Bean Managed Persistence), mapping these methods to SQL INSERT and SELECT operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Standard EJB CRUD operations (Create and Find by Primary Key)",
    "transactionHandling": "Transactions are managed by the EJB Container (CMT) as per the deployment descriptor.",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public CreditCardLocal findByPrimaryKey(Object key) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.creditcard.ejb",
    "mechanism": "EJB",
    "name": "CreditCardEJB",
    "description": "This interface represents the local view of an Enterprise Java Bean (EJB), likely an Entity Bean. In the J2EE architecture, Entity Beans are used to represent persistent data in a database. The container manages the synchronization between this object and the underlying database table.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations managed by the EJB container",
    "transactionHandling": "Managed by the EJB Container (CMT)",
    "protocol": "EJB 2.x",
    "connectionInfo": "Managed by Application Server",
    "codeExample": "public interface CreditCardLocal extends javax.ejb.EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.creditcard.ejb.CreditCardEJB",
    "mechanism": "EJB",
    "name": "CreditCardEJB",
    "description": "The class uses EJB 2.x Container Managed Persistence (CMP). The abstract getters and setters define the persistent fields, and the EJB container handles the actual database interactions (SQL generation, connection management) at runtime.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "CreditCard"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (ORM-style mapping)",
    "transactionHandling": "Container Managed Transactions (JTA)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getCardNumber();\npublic abstract void setCardNumber(String cardNumber);"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.account.ejb",
    "mechanism": "EJB",
    "name": "AccountEJB",
    "description": "The class is an EJB 2.x Entity Bean using Container-Managed Persistence (CMP). The abstract methods (getters/setters) are implemented by the EJB container to perform SQL operations (SELECT, INSERT, UPDATE) against the database. The mapping to specific tables and columns is defined in external XML deployment descriptors (not shown in code).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container-managed CRUD operations",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getStatus(); // CMP field managed by container"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.account.ejb.AccountLocal",
    "mechanism": "EJB",
    "name": "AccountEJB",
    "description": "This is an EJB Local Interface (extending EJBLocalObject), which typically acts as the local view for an Entity Bean. Entity Beans in J2EE are used to represent persistent data in a database. The container handles the synchronization between this object and the database row.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (CMP) or Bean Managed Persistence (BMP) implied by EJB structure.",
    "transactionHandling": "Container Managed Transactions (CMT) typical for EJB Local Objects.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface AccountLocal extends javax.ejb.EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.account.ejb.AccountLocalHome",
    "mechanism": "EJB",
    "name": "AccountEJB",
    "description": "This file is an EJB Local Home interface, which defines the lifecycle methods (create, find) for an Entity Bean. The EJB container intercepts calls to these methods to perform database INSERT and SELECT operations via Container-Managed Persistence (CMP) or Bean-Managed Persistence (BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Account"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Create and Find by Primary Key) managed by the EJB container.",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB specification.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public AccountLocal findByPrimaryKey(Object key) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.ejb.CustomerEJB",
    "mechanism": "EJB",
    "name": "CustomerEJB",
    "description": "This class is an EJB 2.x Entity Bean using Container-Managed Persistence (CMP). The EJB container is responsible for generating the SQL and database connectivity code to persist the 'userId' field and manage the relationships to Account and Profile entities.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (implicit queries)",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getUserId();\npublic abstract void setUserId(String userId);"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.ejb.CustomerLocal",
    "mechanism": "EJB",
    "name": "CustomerEJB",
    "description": "This interface represents the local view of an Entity Bean (likely Container-Managed Persistence - CMP) in a J2EE application. It provides access to persistent customer data and relationships (Account, Profile) managed by the EJB container.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Navigation through EJB relationships (getAccount, getProfile)",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB architecture",
    "protocol": "EJB 2.x",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface CustomerLocal extends javax.ejb.EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.ejb.CustomerLocalHome",
    "mechanism": "EJB",
    "name": "CustomerEntityBean",
    "description": "This is an EJB Entity Bean Home interface. It defines methods that map directly to database operations (INSERT for create, SELECT for finders) managed by the EJB container (CMP) or the bean implementation (BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Customer"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Create, Find by PK, Find All)",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB context",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public CustomerLocal findByPrimaryKey(String userId) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.profile.ejb",
    "mechanism": "EJB",
    "name": "ProfileEJB",
    "description": "The class uses EJB 2.x Container-Managed Persistence (CMP). The abstract getters and setters define the persistent fields, and the EJB container automatically handles the SQL generation, database connection, and synchronization based on the deployment descriptor configuration.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getPreferredLanguage();\npublic abstract void setPreferredLanguage(String preferredLanguage);"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.profile.ejb",
    "mechanism": "EJB",
    "name": "CustomerProfileEJB",
    "description": "This interface acts as the local view for an Enterprise Java Bean (likely an Entity Bean or a Session Bean wrapping an Entity) that persists customer profile data. The actual database interaction is handled by the EJB container (CMP) or the bean implementation (BMP), but this interface defines the data access contract.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations via EJB accessors",
    "transactionHandling": "Managed by EJB Container (CMT)",
    "protocol": "EJB 2.x",
    "connectionInfo": "n/a",
    "codeExample": "public interface ProfileLocal extends javax.ejb.EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.customer.profile.ejb.ProfileLocalHome",
    "mechanism": "EJB",
    "name": "ProfileLocalHome",
    "description": "This interface defines methods for creating and finding EJB instances, which implies database interaction managed by an EJB container. The `create` method corresponds to a database INSERT operation, and the `findByPrimaryKey` method corresponds to a database SELECT operation. This pattern is characteristic of EJB 2.x Container-Managed Persistence (CMP) or Bean-Managed Persistence (BMP), where the application server handles the persistence logic for entity beans.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Profile"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "simple CRUD",
    "transactionHandling": "EJB Container-Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "unknown",
    "codeExample": "public ProfileLocal findByPrimaryKey(Object key) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.lineitem.ejb",
    "mechanism": "EJB",
    "name": "LineItemEJB",
    "description": "This interface represents the local view of an Enterprise Java Bean (EJB), likely an Entity Bean using Container-Managed Persistence (CMP) or Bean-Managed Persistence (BMP). The EJB container manages the synchronization of this object's state with the underlying database table.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "LINEITEM"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM-style persistence managed by the EJB container.",
    "transactionHandling": "Managed by the EJB Container (CMT).",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface LineItemLocal extends EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.lineitem.ejb",
    "mechanism": "EJB",
    "name": "LineItemEJB",
    "description": "This class is an EJB 2.x Container-Managed Persistence (CMP) Entity Bean. The abstract getter and setter methods (e.g., getCategoryId, setQuantity) correspond to persistent fields managed by the EJB container. The container generates the SQL to read/write these fields to a database table based on the deployment descriptor (ejb-jar.xml).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container-managed CRUD operations",
    "transactionHandling": "Container-managed transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getCategoryId();\npublic abstract void setCategoryId(String id);"
  },
  {
    "path": "com.sun.j2ee.blueprints.lineitem.ejb.LineItemLocalHome",
    "mechanism": "EJB",
    "name": "LineItem EJB",
    "description": "This file is the Home interface for an Entity Bean. The 'create' methods correspond to database INSERT operations, and 'findByPrimaryKey' corresponds to a database SELECT operation by primary key. The actual persistence logic (SQL generation and execution) is handled by the EJB container (likely Container-Managed Persistence).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Create and Find by ID) managed by the EJB container.",
    "transactionHandling": "Managed by the EJB Container (CMT).",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "LineItemLocal create(String catId, String prodId, String itemId, String lineNo, int qty, float price, int qtyShipped) throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.admin.ejb",
    "mechanism": "EJB",
    "name": "PurchaseOrder and ProcessManager EJBs",
    "description": "The code interacts with the database indirectly through Enterprise Java Beans (Entity Beans). It uses Local Home interfaces to execute finders and retrieve Entity instances, which represent database rows.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder",
      "LineItem",
      "ProcessManager"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "The code uses EJB Finder methods (findByPrimaryKey, findPOBetweenDates) to retrieve entities and then traverses relationships (getAllItems) to aggregate data in memory.",
    "transactionHandling": "Container-Managed Transactions (CMT) implied by SessionBean usage, though not explicitly annotated in the code snippet.",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI: java:comp/env/ejb/PurchaseOrder, java:comp/env/ejb/ProcessManager",
    "codeExample": "PurchaseOrderLocalHome pohome = getPO();\nCollection poColl = pohome.findPOBetweenDates(start.getTime(), end.getTime());\nIterator it = poColl.iterator();\nwhile((it!= null) && (it.hasNext())) {\n    po = (PurchaseOrderLocal) it.next();\n    // ..."
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.customerrelations.ejb",
    "mechanism": "EJB",
    "name": "PurchaseOrderLocalHome",
    "description": "The code uses EJB 2.x Entity Beans to interact with the database. It utilizes the `PurchaseOrderLocalHome` interface to find a `PurchaseOrderLocal` entity bean by its primary key (the order ID). This abstracts the direct database operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Key-based lookup (findByPrimaryKey)",
    "transactionHandling": "Container-managed transactions (implied by EJB context)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI lookup via ServiceLocator",
    "codeExample": "PurchaseOrderLocal po = poHome.findByPrimaryKey(invoiceXDE.getOrderId());"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.customerrelations.ejb.MailCompletedOrderMDB",
    "mechanism": "EJB",
    "name": "PurchaseOrderEJB",
    "description": "The code uses EJB 2.x Entity Beans to access database information. It uses the `PurchaseOrderLocalHome` interface to find a Purchase Order by its primary key (the order ID) and retrieves the underlying data object.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Entity Bean lookup by Primary Key",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB context",
    "protocol": "EJB 2.x Local Interface",
    "connectionInfo": "JNDI lookup: JNDINames.PURCHASE_ORDER_EJB",
    "codeExample": "PurchaseOrder poData = poHome.findByPrimaryKey(orderId).getData();"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.customerrelations.ejb.MailOrderApprovalMDB",
    "mechanism": "EJB",
    "name": "PurchaseOrderLocalHome",
    "description": "The code interacts with the database via EJB 2.x Entity Beans. It uses the PurchaseOrderLocalHome interface to find PurchaseOrderLocal entity instances by their primary key (OrderId).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Entity Bean lookup by Primary Key (findByPrimaryKey).",
    "transactionHandling": "Container Managed Transactions (implied by EJB context)",
    "protocol": "EJB 2.x Local Interface",
    "connectionInfo": "JNDI Lookup: java:comp/env/ejb/purchaseorder/PurchaseOrder",
    "codeExample": "po = poHome.findByPrimaryKey(co.getOrderId());\nString emailAddress = po.getPoEmailId();"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.ejb",
    "mechanism": "EJB",
    "name": "PurchaseOrderLocalHome",
    "description": "The code uses EJB 2.x Entity Beans (Local Interfaces) to persist data. It utilizes `PurchaseOrderLocalHome` to create new Purchase Order entities in the underlying database.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "Entity Bean creation (INSERT)",
    "transactionHandling": "Container Managed Transactions (implied by EJB MDB context)",
    "protocol": "EJB 2.x CMP/BMP",
    "connectionInfo": "Managed by J2EE Container via JNDI lookup of 'java:comp/env/ejb/PurchaseOrderEJB'",
    "codeExample": "poHome = (PurchaseOrderLocalHome)serviceLocator.getLocalHome(JNDINames.PURCHASE_ORDER_EJB);\n// ...\nPurchaseOrder purchaseOrder = PurchaseOrder.fromXML(xmlMessage, entityCatalogURL, validateXmlPurchaseOrder);\npoHome.create(purchaseOrder);"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.ejb.InvoiceMDB",
    "mechanism": "EJB",
    "name": "PurchaseOrder and ProcessManager Entity Beans",
    "description": "The class interacts with the database through EJB 2.x Entity Beans. It uses `PurchaseOrderLocalHome` to find purchase orders by primary key and `ProcessManagerLocalHome` to create or find process managers. The actual persistence logic is abstracted by the EJB container (CMP or BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder",
      "ProcessManager"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Lookup by Primary Key via EJB Home interface",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB context",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI lookup via ServiceLocator",
    "codeExample": "poHome = (PurchaseOrderLocalHome)serviceLocator.getLocalHome(JNDINames.PURCHASE_ORDER_EJB);\nPurchaseOrderLocal po = poHome.findByPrimaryKey(invoiceXDE.getOrderId());\nprocessManager.updateStatus(invoiceXDE.getOrderId(), OrderStatusNames.COMPLETED);"
  },
  {
    "path": "com.sun.j2ee.blueprints.opc.ejb.OrderApprovalMDB",
    "mechanism": "EJB",
    "name": "PurchaseOrderEJB",
    "description": "The code interacts with the database using EJB 2.x Entity Beans (`PurchaseOrderLocal`) and Session Beans (`ProcessManagerLocal`). It retrieves purchase orders by primary key and updates order statuses via the process manager.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder",
      "LineItem",
      "Address",
      "ContactInfo"
    ],
    "operationType": [
      "READ",
      "WRITE"
    ],
    "queryPatterns": "Lookup by Primary Key (findByPrimaryKey) and updates via Session Facade.",
    "transactionHandling": "Container Managed Transactions (Implicit in EJB MDB)",
    "protocol": "EJB 2.x Local Interfaces",
    "connectionInfo": "JNDI Lookup via ServiceLocator",
    "codeExample": "po = poHome.findByPrimaryKey(co.getOrderId());\nprocessManager.updateStatus(co.getOrderId(), co.getOrderStatus());"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.ejb",
    "mechanism": "EJB",
    "name": "CustomerLocalHome",
    "description": "The code interacts with the database through Enterprise JavaBeans (EJB) Entity Beans. Specifically, it uses the `CustomerLocalHome` interface to find and create Customer entities, which represent persistent data in the underlying database.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Customer"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB Entity Bean lookups (findByPrimaryKey) and creation.",
    "transactionHandling": "Container-managed transactions (standard for Session Beans invoking Entity Beans).",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI Lookup: JNDINames.CUSTOMER_EJBHOME",
    "codeExample": "ServiceLocator sl = new ServiceLocator();\nCustomerLocalHome home =(CustomerLocalHome)sl.getLocalHome(JNDINames.CUSTOMER_EJBHOME);\ncustomer = home.findByPrimaryKey(userId);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.ejb.ShoppingClientFacadeLocal",
    "mechanism": "EJB",
    "name": "ShoppingClientFacade",
    "description": "This interface represents a J2EE Enterprise Java Bean (EJB) Local Interface. While the interface itself does not contain SQL, it defines the contract for a Session Bean that orchestrates Entity Beans (CustomerLocal) which map directly to database tables. The `getCustomer` and `createCustomer` methods imply direct interaction with the persistence layer via the EJB container.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Customer"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB Entity Bean lookups and creation",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB architecture",
    "protocol": "unknown",
    "connectionInfo": "Managed by J2EE Container",
    "codeExample": "public interface ShoppingClientFacadeLocal extends EJBLocalObject {\n    public CustomerLocal getCustomer() throws FinderException;\n}"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.ejb.actions",
    "mechanism": "EJB",
    "name": "ProfileLocal",
    "description": "The code interacts with the persistence layer through Enterprise Java Beans (EJB). Specifically, it accesses the `ProfileLocal` entity bean to retrieve customer profile information (preferred language). The presence of `FinderException` handling indicates a database lookup operation.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Profile",
      "Customer"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Entity Bean traversal (getProfile) and property access",
    "transactionHandling": "Container Managed Transactions (implied by EJB context)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "n/a",
    "codeExample": "ProfileLocal profile = scf.getCustomer().getProfile();\nLocale locale = I18nUtil.getLocaleFromString(profile.getPreferredLanguage());"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.ejb.actions",
    "mechanism": "EJB",
    "name": "SignOnLocal",
    "description": "The class delegates database persistence operations to the SignOnLocal Enterprise Java Bean. While this class does not contain direct SQL, it invokes the transactional 'createUser' method on the EJB, which is responsible for persisting the user credentials to the underlying data store.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "Delegated to EJB (likely transactional INSERT)",
    "transactionHandling": "Container Managed Transactions (implied by EJB usage)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI Lookup: JNDINames.SIGN_ON_EJBHOME",
    "codeExample": "SignOnLocalHome home =(SignOnLocalHome)sl.getLocalHome(JNDINames.SIGN_ON_EJBHOME);\nsignOn = home.create();\nsignOn.createUser(userName, password);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.ejb.actions.CustomerEJBAction",
    "mechanism": "EJB",
    "name": "ShoppingClientFacadeLocal",
    "description": "The code interacts with the database through Enterprise JavaBeans (Entity Beans) accessed via a Session Facade. It retrieves Local Interfaces for Customer, Account, ContactInfo, Address, and CreditCard entities and performs updates by calling setter methods on these persistent objects.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Customer",
      "Account",
      "ContactInfo",
      "Address",
      "CreditCard",
      "Profile"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Navigation through Entity Bean relationships (getAccount, getContactInfo) and updates via setter methods.",
    "transactionHandling": "Likely handled by the EJB container (CMT) on the perform method or the facade methods.",
    "protocol": "EJB Local Interface",
    "connectionInfo": "n/a",
    "codeExample": "CustomerLocal customer = scf.getCustomer();\nAccountLocal account = customer.getAccount();\nContactInfoLocal contactInfoLocal = account.getContactInfo();\ncontactInfoLocal.setFamilyName(contactInfo.getFamilyName());"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.web",
    "mechanism": "EJB",
    "name": "ShoppingController",
    "description": "The class interacts with the persistence tier through Enterprise Java Beans (EJB). It uses a ServiceLocator to look up the 'ShoppingControllerLocalHome' via JNDI and creates a 'ShoppingControllerLocal' EJB. This EJB acts as a facade to manage data related to shopping carts and customers.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB Entity/Session bean access via Home interfaces",
    "transactionHandling": "Container Managed Transactions (CMT) likely handled by the EJB container",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI Lookup: JNDINames.SHOPPING_CONTROLLER_EJBHOME",
    "codeExample": "ShoppingControllerLocalHome scEjbHome =\n   (ShoppingControllerLocalHome)serviceLocator.getLocalHome(JNDINames.SHOPPING_CONTROLLER_EJBHOME);\nscEjb = scEjbHome.create();"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.controller.web",
    "mechanism": "EJB",
    "name": "ShoppingControllerLocal",
    "description": "This class interacts with the ShoppingControllerLocal Enterprise Java Bean. While it does not execute SQL directly, it delegates business operations to the EJB layer which is responsible for transaction management and persistence operations within the J2EE container.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Delegates to EJB",
    "transactionHandling": "Managed by EJB Container (Stateful Session Bean)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "n/a",
    "codeExample": "ShoppingControllerLocal scEjb = pcm.getShoppingController(session);\nreturn scEjb.processEvent(ev);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "EJB",
    "name": "ProfileLocalHome",
    "description": "The class interacts with the database via Enterprise Java Beans (EJB) 2.x Entity Beans. It looks up the Local Home interface using JNDI and invokes the `create` method to persist a new Profile entity.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Profile"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "EJB Entity Bean creation (INSERT)",
    "transactionHandling": "Container Managed (implied by EJB)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "java:comp/env/ejb/Profile",
    "codeExample": "InitialContext context = new InitialContext();\nprofileHome = (ProfileLocalHome) context.lookup(JNDI_PROFILE_HOME);\nreturn profileHome.create(preferredLanguage, favoriteCategory, myListPreference, bannerPreference);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "EJB",
    "name": "Account EJB",
    "description": "The class uses Enterprise Java Beans (EJB 2.x) Entity Beans to persist account data. It interacts with the container via JNDI to locate the Home interface and creates new entities.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Account"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "EJB Create Method",
    "transactionHandling": "Container Managed (EJB)",
    "protocol": "EJB/RMI",
    "connectionInfo": "JNDI: java:comp/env/ejb/Account",
    "codeExample": "InitialContext context = new InitialContext();\naccountHome = (AccountLocalHome) context.lookup(JNDI_ACCOUNT_HOME);\nreturn accountHome.create(AccountLocalHome.Active, contactInfo, creditCard);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "EJB",
    "name": "CreditCardEJB",
    "description": "The code interacts with the database through Enterprise Java Beans (EJB). It looks up the Local Home interface for the CreditCard EJB and invokes the `create` method, which delegates the actual database INSERT operation to the EJB container (likely CMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "CreditCard"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "EJB Entity Bean creation (INSERT)",
    "transactionHandling": "Container Managed Transactions (implied by EJB)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI: java:comp/env/ejb/CreditCard",
    "codeExample": "InitialContext context = new InitialContext();\ncreditCardHome = (CreditCardLocalHome) context.lookup(JNDI_CREDIT_CARD_HOME);\nreturn creditCardHome.create(cardNumber, cardType, expiryDate);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "EJB",
    "name": "UserLocalHome",
    "description": "The class uses Enterprise JavaBeans (EJB) Entity Beans to interact with the database. It obtains a reference to the UserLocalHome interface via JNDI and uses it to create and find User entities.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "User"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB CMP/BMP operations (create, findByPrimaryKey, findAllUsers)",
    "transactionHandling": "Container-managed transactions (implied by EJB usage)",
    "protocol": "EJB 2.x",
    "connectionInfo": "JNDI: java:comp/env/ejb/User",
    "codeExample": "InitialContext context = new InitialContext();\nuserHome = (UserLocalHome) context.lookup(JNDI_USER_HOME);\nuser = userHome.create(id, password);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.AddressPopulator",
    "mechanism": "EJB",
    "name": "AddressLocalHome",
    "description": "The code uses Enterprise JavaBeans (EJB) 2.x Local Interfaces to persist data. It looks up the EJB Home interface via JNDI and uses the `create()` factory method to instantiate a new persistent entity, then populates its fields via setter methods.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Address"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "ORM-style entity creation via EJB Container",
    "transactionHandling": "Container Managed (implied by EJB)",
    "protocol": "EJB Container Protocol",
    "connectionInfo": "java:comp/env/ejb/Address",
    "codeExample": "InitialContext context = new InitialContext();\naddressHome = (AddressLocalHome) context.lookup(JNDI_ADDRESS_HOME);\nAddressLocal address = addressHome.create();\naddress.setStreetName1(streetName1);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.ContactInfoPopulator",
    "mechanism": "EJB",
    "name": "ContactInfoLocalHome",
    "description": "The class uses Enterprise Java Beans (EJB 2.x) Entity Beans to persist data. It looks up the Local Home interface via JNDI and uses the `create` method to insert data.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "ContactInfo"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "ORM entity creation via EJB Home interface",
    "transactionHandling": "Container-managed transactions (implied by EJB)",
    "protocol": "EJB/JNDI",
    "connectionInfo": "java:comp/env/ejb/ContactInfo",
    "codeExample": "InitialContext context = new InitialContext();\ncontactInfoHome = (ContactInfoLocalHome) context.lookup(JNDI_CONTACT_INFO_HOME);\nreturn contactInfoHome.create(givenName, familyName, phone, email, address);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.CustomerPopulator",
    "mechanism": "EJB",
    "name": "CustomerEJB",
    "description": "The class interacts with the database via Enterprise Java Beans (EJB 2.x) Entity Beans. It uses the CustomerLocalHome interface to find, create, and remove Customer entities. It also interacts with AccountLocal and ProfileLocal interfaces to manage related data.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Customer",
      "Account",
      "Profile"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB Finder methods (findAllCustomers, findByPrimaryKey) and CRUD operations (create, remove).",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB usage.",
    "protocol": "EJB 2.0 Local Interfaces",
    "connectionInfo": "JNDI: java:comp/env/ejb/Customer",
    "codeExample": "customerHome = (CustomerLocalHome) context.lookup(JNDI_CUSTOMER_HOME);\nCustomerLocal customer = customerHome.create(id);"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.ejb",
    "mechanism": "EJB",
    "name": "ManagerLocalHome",
    "description": "The class interacts with the database indirectly through EJB Entity Beans. It uses the `ManagerLocalHome` interface to find, create, and update `ManagerLocal` entities, which represent persistent data (likely orders). The actual SQL or database interaction is handled by the EJB container's persistence mechanism (CMP or BMP) associated with the `Manager` bean.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations via EJB Home interface finders and creators",
    "transactionHandling": "Container Managed Transactions (implied by EJB)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI: java:comp/env/ejb/Manager",
    "codeExample": "ManagerLocal manager = mlh.findByPrimaryKey(orderId);\nmanager.setStatus(status);"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.ejb",
    "mechanism": "EJB",
    "name": "ProcessManager Persistence",
    "description": "The interface extends EJBLocalObject and declares methods throwing CreateException and FinderException, which are standard EJB patterns for interacting with a persistence layer (likely Entity Beans or direct JDBC within a Session Bean). The methods imply CRUD operations on an order process entity.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations (Create, Read, Update) and a finder query by status.",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB architecture.",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public void createManager (String orderId, String status) throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.ejb.ProcessManagerLocalHome",
    "mechanism": "EJB",
    "name": "ProcessManager Entity EJB",
    "description": "This is a Home interface for an Entity EJB, which represents a persistent data object. The create method typically corresponds to an INSERT operation in the underlying database, managed either by the container (CMP) or the bean implementation (BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "Entity Bean creation typically maps to a SQL INSERT.",
    "transactionHandling": "Transactions are typically Container-Managed (CMT) via JTA.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public ProcessManagerLocal create() throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.manager.ejb",
    "mechanism": "EJB",
    "name": "ProcessManager Entity Bean",
    "description": "This file is an EJB Entity Bean Home interface. It defines persistence operations (create, find) that the EJB container maps to database operations (INSERT, SELECT).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Create by ID, Find by Primary Key, Find by Status attribute)",
    "transactionHandling": "Container Managed Transactions (CMT) provided by the EJB container",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public ManagerLocal create(String orderId, String status) throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.manager.ejb",
    "mechanism": "EJB",
    "name": "ManagerEJB",
    "description": "The class uses EJB 2.x Container-Managed Persistence (CMP). The abstract class defines the data schema via abstract getters and setters, and the EJB container is responsible for generating the SQL and database connectivity code at deployment time.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container-Managed Persistence (CMP) handles queries automatically based on deployment descriptors.",
    "transactionHandling": "Container-Managed Transactions (CMT) handled by the EJB container.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract class ManagerEJB implements EntityBean {\n    // CMP fields\n    public abstract String getOrderId();\n    public abstract void setOrderId(String orderId);\n    // ...\n}"
  },
  {
    "path": "com.sun.j2ee.blueprints.processmanager.manager.ejb.ManagerLocal",
    "mechanism": "EJB",
    "name": "ManagerEJB",
    "description": "This interface represents the local view of an Enterprise Java Bean (EJB). In the context of J2EE Blueprints, this likely corresponds to an Entity Bean or a Session Bean that manages persistence for process manager state. The methods defined (getOrderId, getStatus, setStatus) imply a direct mapping to persistent fields or a stateful workflow backed by a database.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "CRUD operations via EJB container management",
    "transactionHandling": "Container-Managed Transactions (CMT) implied by EJB architecture",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface ManagerLocal extends javax.ejb.EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.purchaseorder.ejb",
    "mechanism": "EJB",
    "name": "PurchaseOrder/LineItem Entity Beans",
    "description": "The code interacts with the database through EJB Entity Beans (Local interfaces). It navigates the relationship between PurchaseOrder and LineItems and updates the persistent state (quantityShipped) of LineItem entities.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder",
      "LineItem"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Navigation of entity relationships and update of scalar fields.",
    "transactionHandling": "Likely Container Managed Transactions (CMT) propagated from the caller.",
    "protocol": "EJB Local Interface",
    "connectionInfo": "n/a",
    "codeExample": "LineItemLocal li = (LineItemLocal) liIt.next();\nif(lineItemIds.containsKey(li.getItemId())) {\n    Integer shipped = (Integer) lineItemIds.get(li.getItemId());\n    li.setQuantityShipped(li.getQuantityShipped() + shipped.intValue());\n}"
  },
  {
    "path": "com.sun.j2ee.blueprints.purchaseorder.ejb.PurchaseOrderEJB",
    "mechanism": "EJB",
    "name": "PurchaseOrderEJB",
    "description": "The class is an EJB 2.0 Entity Bean using Container-Managed Persistence (CMP). The abstract getters and setters map directly to database columns managed by the EJB container. Relationships with other entities (LineItems, ContactInfo) are handled via Container-Managed Relationships (CMR).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "unknown",
    "codeExample": "public abstract String getPoId();\npublic abstract void setPoId(String id);"
  },
  {
    "path": "com.sun.j2ee.blueprints.purchaseorder.ejb.PurchaseOrderLocal",
    "mechanism": "EJB",
    "name": "PurchaseOrder",
    "description": "This interface defines an EJB Entity Bean using Container Managed Persistence (CMP). The comments explicitly mention 'getters and setters for PO CMP fields', indicating that the EJB container is responsible for mapping these methods to database columns and handling persistence automatically.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PURCHASE_ORDER"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed Transactions (CMT) typical for EJB Entity Beans",
    "protocol": "unknown",
    "connectionInfo": "Managed by J2EE Container",
    "codeExample": "public String getPoId();\npublic void setContactInfo(ContactInfoLocal addr);"
  },
  {
    "path": "com.sun.j2ee.blueprints.purchaseorder.ejb.PurchaseOrderLocalHome",
    "mechanism": "EJB",
    "name": "PurchaseOrderLocalHome",
    "description": "This interface defines methods for creating and finding PurchaseOrder EJB instances, which is a core part of the EJB 2.x persistence framework. While it doesn't contain direct database access code itself, the EJB container implements these methods to interact with the database. The `create` and `find...` methods are mapped to underlying persistence operations (e.g., SQL INSERT and SELECT statements) against the table corresponding to the PurchaseOrder entity. This pattern is characteristic of Container-Managed Persistence (CMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "PurchaseOrder"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Defines standard primary key lookups and a custom finder method for querying by a date range. These are mapped by the EJB container to corresponding SQL queries.",
    "transactionHandling": "Transactions are managed by the EJB container, typically using JTA (Java Transaction API). Method calls to the EJB are automatically enlisted in a transaction, which is either started by the container or propagated from the client.",
    "protocol": "unknown",
    "connectionInfo": "unknown",
    "codeExample": "public PurchaseOrderLocal findByPrimaryKey(String poId) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.ejb",
    "mechanism": "EJB",
    "name": "UserLocalHome",
    "description": "The class interacts with the database indirectly through Enterprise Java Beans (Entity Beans). It uses the `UserLocalHome` interface to find and create `UserLocal` entities, which represent rows in the underlying database table. The actual SQL generation and execution are handled by the EJB container (CMP) or the Entity Bean implementation (BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "User"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Entity Bean lookups (findByPrimaryKey) and creation",
    "transactionHandling": "Container Managed Transactions (implied by EJB SessionBean)",
    "protocol": "EJB 2.x",
    "connectionInfo": "java:comp/env/ejb/User",
    "codeExample": "UserLocal user = ulh.findByPrimaryKey(userName);"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.ejb.SignOnLocalHome",
    "mechanism": "EJB",
    "name": "SignOn Entity Bean",
    "description": "This file is the Home interface for an EJB Entity Bean. The `create()` method corresponds to the creation of a persistent entity, which implies a database INSERT operation managed by the EJB container (CMP) or the bean implementation (BMP).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "Entity creation (INSERT)",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB standard",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public SignOnLocal create() throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.user.ejb",
    "mechanism": "EJB",
    "name": "User Entity Bean",
    "description": "This interface represents the local view of an Entity Bean, which is a J2EE component model specifically designed for database persistence. The methods defined (get/set password, getUserName) map directly to columns in a database table (likely a 'Users' or 'SignOn' table). In EJB 2.x, the container handles the synchronization between this object and the database row.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "User"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM-style entity access managed by the EJB container.",
    "transactionHandling": "Transactions are typically managed declaratively by the EJB container (CMT) via deployment descriptors.",
    "protocol": "EJB 2.x Container Protocol",
    "connectionInfo": "Managed by J2EE Container",
    "codeExample": "public interface UserLocal extends javax.ejb.EJBLocalObject {\n    public String getUserName();\n    public void setPassword(String password);\n}"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.user.ejb.UserEJB",
    "mechanism": "EJB",
    "name": "UserEJB",
    "description": "The class uses EJB 2.x Container-Managed Persistence (CMP). The abstract methods `getUserName`/`setUserName` and `getPassword`/`setPassword` are implemented by the EJB container to map directly to database columns. The container handles the generation of SQL for INSERT, UPDATE, SELECT, and DELETE operations based on the deployment descriptor configuration.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations managed by the container.",
    "transactionHandling": "Container Managed Transactions (CMT) via EJB Context.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getUserName();\npublic abstract void setUserName(String userName);"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.user.ejb.UserLocalHome",
    "mechanism": "EJB",
    "name": "UserLocalHome",
    "description": "This interface defines the contract for an EJB 2.x Entity Bean's local home. It provides methods for creating and finding 'User' entities. The EJB container implements this interface at deployment time, generating the necessary data access logic (typically SQL) to interact with a database based on the EJB's deployment descriptor (e.g., ejb-jar.xml). The methods 'create', 'findByPrimaryKey', and 'findAllUsers' correspond to database INSERT and SELECT operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "User"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "EJB-QL or container-managed persistence finders. The `create` method maps to an INSERT. `findByPrimaryKey` maps to a `SELECT` by primary key. `findAllUsers` maps to a `SELECT` for all rows.",
    "transactionHandling": "Container-Managed Transactions (CMT). The EJB container automatically manages transaction boundaries for these methods, as is standard for EJB entity beans.",
    "protocol": "unknown",
    "connectionInfo": "unknown",
    "codeExample": "public UserLocal findByPrimaryKey (String userName) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.web",
    "mechanism": "EJB",
    "name": "SignOn",
    "description": "The servlet interacts with the database indirectly through an Enterprise Java Bean (SignOnLocal). The EJB encapsulates the persistence logic for creating a user.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "WRITE"
    ],
    "queryPatterns": "n/a",
    "transactionHandling": "unknown",
    "protocol": "EJB Local Interface",
    "connectionInfo": "java:comp/env/ejb/SignOn",
    "codeExample": "InitialContext ic = new InitialContext();\nObject o = ic.lookup(\"java:comp/env/ejb/SignOn\");\nSignOnLocalHome home =(SignOnLocalHome)o;\nsignOn = home.create();\nsignOn.createUser(userName, password);"
  },
  {
    "path": "com.sun.j2ee.blueprints.signon.web.SignOnFilter",
    "mechanism": "EJB",
    "name": "SignOn EJB",
    "description": "The filter delegates the actual database authentication logic to an Enterprise JavaBean (`SignOnLocal`). The filter looks up the EJB via JNDI and invokes the `authenticate` method, which presumably interacts with the database to verify credentials.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "n/a",
    "transactionHandling": "unknown",
    "protocol": "EJB Local Interface",
    "connectionInfo": "java:comp/env/ejb/SignOn",
    "codeExample": "InitialContext ic = new InitialContext();\nObject o = ic.lookup(\"java:comp/env/ejb/SignOn\");\nSignOnLocalHome home =(SignOnLocalHome)o;\nsignOn = home.create();\nboolean authenticated = signOn.authenticate(userName, password);"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.inventory.ejb",
    "mechanism": "EJB",
    "name": "InventoryEJB",
    "description": "The class uses EJB 2.x Container-Managed Persistence (CMP). The EJB container automatically handles the database interactions (SELECT, INSERT, UPDATE, DELETE) based on the abstract accessor methods defined in this class and the deployment descriptor mapping.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public abstract String getItemId();\npublic abstract void setItemId(String itemId);"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.inventory.ejb",
    "mechanism": "EJB",
    "name": "Inventory CMP Bean",
    "description": "This interface represents a Container Managed Persistence (CMP) Entity Bean. The EJB container automatically handles the synchronization of the bean's state (itemId, quantity) with the underlying database table based on the deployment descriptor.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Inventory"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM-style persistence managed by the EJB container",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB specification",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface InventoryLocal extends EJBLocalObject"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.inventory.ejb",
    "mechanism": "EJB",
    "name": "Inventory CMP Bean",
    "description": "The code defines an EJB Local Home interface for a Container Managed Persistence (CMP) bean. The EJB container handles the actual database interactions (SQL generation, connection management) based on this interface and the associated deployment descriptors.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Create, Find By ID, Find All)",
    "transactionHandling": "Container Managed Transactions (CMT) implied by EJB context",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public InventoryLocal create(String itemId, int quantity)\n    throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.inventory.web",
    "mechanism": "EJB",
    "name": "InventoryLocalHome",
    "description": "The class interacts with the database indirectly by invoking methods on an Enterprise JavaBean (EJB) Local Home interface. The `findAllInventoryItems` method on the EJB likely executes a database query (SQL or JPQL) to retrieve all inventory records.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "The method name `findAllInventoryItems` suggests a 'Select All' style query pattern, likely returning a collection of entity beans or DTOs.",
    "transactionHandling": "unknown",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI Name: JNDINames.INV_EJB",
    "codeExample": "inventoryHomeRef = (InventoryLocalHome)\n             serviceLocator.getLocalHome(JNDINames.INV_EJB);\ninvColl = inventoryHomeRef.findAllInventoryItems();"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.inventory.web",
    "mechanism": "EJB",
    "name": "InventoryLocal, OrderFulfillmentFacadeLocal",
    "description": "The code interacts with the database using EJB 2.x Entity Beans (`InventoryLocal`) and Session Beans (`OrderFulfillmentFacadeLocal`). It performs explicit transaction management using JTA `UserTransaction` to wrap multiple database operations (finding and updating inventory items) into a single atomic unit.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Manual JTA UserTransaction (begin/commit)",
    "protocol": "unknown",
    "connectionInfo": "JNDI lookup via ServiceLocator",
    "codeExample": "ut = (UserTransaction) ic.lookup(JNDINames.USER_TRANSACTION);\nut.begin();\n// ...\ninventory = inventoryHomeRef.findByPrimaryKey(itemId);\ninventory.setQuantity(qty.intValue());\n// ...\nut.commit();"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.orderfulfillment.ejb.OrderFulfillmentFacadeEJB",
    "mechanism": "EJB",
    "name": "SupplierOrderLocalHome, InventoryLocalHome",
    "description": "The application uses EJB 2.x Entity Beans to interact with the database. It persists new orders using the `SupplierOrderLocalHome` interface and manages inventory levels using the `InventoryLocalHome` interface. The persistence logic is abstracted behind these EJB interfaces, which handle the underlying database operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "SupplierOrder",
      "Inventory",
      "LineItem"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Transactional CRUD operations via EJB Entity Beans. Includes finding by primary key, finding by status, creating new entities, and updating entity fields (reducing inventory).",
    "transactionHandling": "JPA ENTITYTRANSACTION",
    "protocol": "EJB 2.x Entity Beans",
    "connectionInfo": "Managed by EJB Container (JNDI lookups)",
    "codeExample": "InventoryLocal inv = invHome.findByPrimaryKey(item.getItemId());\nif(inv.getQuantity() < item.getQuantity())\n  return(false);\ninv.reduceQuantity(item.getQuantity());"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.orderfulfillment.ejb.OrderFulfillmentFacadeLocal",
    "mechanism": "EJB",
    "name": "OrderFulfillmentFacade",
    "description": "This is an EJB Local Interface that defines business methods implying database interaction. The `processPO` method suggests data creation (INSERT), and `processPendingPO` throws `FinderException`, which is explicitly used in EJB to signal issues finding data in a database (SELECT). The underlying implementation would typically use EJB Entity Beans or JDBC.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Likely involves creating new records for Purchase Orders and querying for records with a 'PENDING' status.",
    "transactionHandling": "EJB methods typically run within Container-Managed Transactions (CMT) by default.",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public Collection processPendingPO() throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.processpo.ejb.SupplierOrderMDB",
    "mechanism": "EJB",
    "name": "OrderFulfillmentFacade",
    "description": "The class delegates data persistence and business logic to a local Enterprise Java Bean (Entity or Session facade). It does not execute SQL directly but relies on the `OrderFulfillmentFacadeLocal` component to persist purchase order data and generate invoices.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Delegated to EJB Facade",
    "transactionHandling": "Container Managed (implied by EJB context)",
    "protocol": "EJB Local Interface",
    "connectionInfo": "JNDI: JNDINames.ORDERFACADE_EJB",
    "codeExample": "OrderFulfillmentFacadeLocalHome ref = (OrderFulfillmentFacadeLocalHome)\n                                  serviceLocator.getLocalHome(JNDINames.ORDERFACADE_EJB);\npoProcessor = ref.create();\n// ...\ninvoice = poProcessor.processPO(xmlMessage);"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplier.tools.populate",
    "mechanism": "EJB",
    "name": "InventoryLocalHome",
    "description": "The class uses Enterprise JavaBeans (EJB) 2.x Entity Beans to manage persistence. It looks up the Local Home interface via JNDI and uses it to find, remove, and create inventory items.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Inventory"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed (Implicit via EJB)",
    "protocol": "unknown",
    "connectionInfo": "java:comp/env/ejb/Inventory",
    "codeExample": "InitialContext context = new InitialContext();\ninventoryHome = (InventoryLocalHome) context.lookup(JNDI_INVENTORY_HOME);\n// ...\ninventory = inventoryHome.create(id, quantity);"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplierpo.ejb",
    "mechanism": "EJB",
    "name": "SupplierOrderEJB",
    "description": "The class is an EJB 2.0 Entity Bean using Container-Managed Persistence (CMP). The EJB container handles the persistence of fields (PoId, PoDate, PoStatus) and relationships (ContactInfo, LineItems) to the underlying database.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "SupplierOrder",
      "LineItem",
      "ContactInfo"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (CMP) handles CRUD operations.",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public abstract String getPoId();\npublic abstract void setPoId(String id);"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplierpo.ejb",
    "mechanism": "EJB",
    "name": "SupplierOrder Entity Bean",
    "description": "The code defines an EJB Local Interface for an Entity Bean using Container Managed Persistence (CMP). The comments explicitly mention 'CMP fields', indicating that the EJB container automatically handles the persistence of fields like PoId, PoDate, and PoStatus to the underlying database.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "SupplierOrder"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Container Managed Persistence (CMP) handles queries automatically based on field access.",
    "transactionHandling": "Container Managed Transactions (CMT) are standard for EJB Entity Beans.",
    "protocol": "unknown",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public interface SupplierOrderLocal extends EJBLocalObject{\n    // getters and setters for PO CMP fields\n    public String getPoId();"
  },
  {
    "path": "com.sun.j2ee.blueprints.supplierpo.ejb",
    "mechanism": "EJB",
    "name": "SupplierOrderLocalHome",
    "description": "This is an EJB Entity Bean Home interface. It defines methods that the EJB container maps to database operations (INSERT for create, SELECT for finders).",
    "databaseName": "unknown",
    "tablesAccessed": [
      "SupplierOrder"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD and conditional search based on status",
    "transactionHandling": "Container Managed Transactions (implied by EJB architecture)",
    "protocol": "unknown",
    "connectionInfo": "managed by container",
    "codeExample": "SupplierOrderLocal create(SupplierOrder supplierOrder) throws CreateException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.uidgen.counter.ejb",
    "mechanism": "EJB",
    "name": "CounterEJB",
    "description": "The class uses EJB 2.x Container-Managed Persistence (CMP). The EJB container automatically handles the mapping of the abstract 'counter' and 'name' fields to columns in a database table. The developer does not write SQL; instead, the container generates the necessary JDBC calls at runtime based on deployment descriptors.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "ORM QUERIES",
    "transactionHandling": "Container Managed Transactions (CMT)",
    "protocol": "unknown",
    "connectionInfo": "n/a",
    "codeExample": "public abstract int getCounter();\npublic abstract void setCounter(int counter);"
  },
  {
    "path": "com.sun.j2ee.blueprints.uidgen.counter.ejb.CounterLocalHome",
    "mechanism": "EJB",
    "name": "Counter EJB Persistence",
    "description": "This file is an EJB Local Home interface. In EJB 2.x architecture, methods defined here (create, findByPrimaryKey) directly map to persistence operations managed by the container (CMP) or the bean implementation (BMP). The 'create' method implies an INSERT operation, and 'findByPrimaryKey' implies a SELECT operation by ID.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "unknown"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Simple CRUD operations (Insert and Select by Primary Key) managed by the EJB container.",
    "transactionHandling": "Container Managed Transactions (CMT) are standard for EJB Home interfaces.",
    "protocol": "EJB 2.x Container Protocol",
    "connectionInfo": "Managed by EJB Container",
    "codeExample": "public CounterLocal findByPrimaryKey(String name) throws FinderException;"
  },
  {
    "path": "com.sun.j2ee.blueprints.uidgen.ejb.UniqueIdGeneratorEJB",
    "mechanism": "EJB",
    "name": "Counter",
    "description": "The class interacts with the persistence layer through EJB 2.x Entity Beans. It uses the CounterLocalHome interface to find existing Counter entities by their primary key or create new ones if they do not exist. This implies an underlying database table where counter states are stored.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Counter"
    ],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Entity Bean finder (findByPrimaryKey) and creation (create) methods.",
    "transactionHandling": "Container-managed transactions (implied by EJB context).",
    "protocol": "EJB 2.x Entity Bean",
    "connectionInfo": "JNDI: java:comp/env/ejb/Counter",
    "codeExample": "counter = clh.findByPrimaryKey(name);\n} catch (FinderException fe) {\n    counter = clh.create(name);\n}"
  },
  {
    "path": "src/lib/jstl/sql.tld",
    "mechanism": "JDBC",
    "name": "JSTL SQL Tag Library",
    "description": "This file defines the interface for the JSTL SQL library, which provides a direct wrapper around JDBC functionality for use in JSP pages. It defines tags that allow setting up JDBC DataSources, executing SQL queries and updates, and managing database transactions.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE",
      "DDL",
      "OTHER"
    ],
    "queryPatterns": "Arbitrary SQL queries and updates defined by the user in JSP pages using the <sql:query> and <sql:update> tags.",
    "transactionHandling": "Provides a <transaction> tag that wraps other database tags to execute them within a single JDBC transaction context.",
    "protocol": "JDBC",
    "connectionInfo": "Dynamic connection configuration via <setDataSource> attributes: driver, url, user, password",
    "codeExample": "<tag>\n    <name>setDataSource</name>\n    <tag-class>org.apache.taglibs.standard.tag.el.sql.SetDataSourceTag</tag-class>\n    <body-content>empty</body-content>\n    <description>\n        Creates a simple DataSource suitable only for prototyping.\n    </description>\n    <attribute>\n        <name>driver</name>\n        <required>false</required>\n        <rtexprvalue>false</rtexprvalue>\n    </attribute>\n    <attribute>\n        <name>url</name>\n        <required>false</required>\n        <rtexprvalue>false</rtexprvalue>\n    </attribute>\n</tag>"
  },
  {
    "path": "src/lib/jstl/sql-rt.tld",
    "mechanism": "JDBC",
    "name": "JSTL SQL Tag Library",
    "description": "This TLD defines the interface for JSTL SQL tags, which act as wrappers around JDBC functionality. It enables the execution of arbitrary SQL statements directly from JSP pages by mapping XML tags to Java classes that manage JDBC Connections, Statements, and ResultSets.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "Arbitrary SQL queries and updates defined directly within JSP pages using the <sql:query> and <sql:update> tags.",
    "transactionHandling": "Explicit transaction management is supported via the <sql:transaction> tag, which groups nested database operations into a single JDBC transaction.",
    "protocol": "JDBC",
    "connectionInfo": "Dynamic connection configuration via the <setDataSource> tag attributes (driver, url, user, password)",
    "codeExample": "<tag>\n    <name>query</name>\n    <tag-class>org.apache.taglibs.standard.tag.rt.sql.QueryTag</tag-class>\n    <body-content>JSP</body-content>\n    <description>\n        Executes the SQL query defined in its body or through the\n        sql attribute.\n    </description>\n..."
  },
  {
    "path": "com.sun.j2ee.blueprints.catalog.dao.CloudscapeCatalogDAO",
    "mechanism": "JDBC",
    "name": "CloudscapeCatalogDAO",
    "description": "The class uses raw JDBC (Java Database Connectivity) to interact with a Cloudscape database. It obtains connections via a DataSource looked up through JNDI. It uses PreparedStatement for all queries to handle parameters safely. The code manually manages resources (Connection, PreparedStatement, ResultSet) using try-catch-finally blocks (or close calls within the try block in this specific legacy style).",
    "databaseName": "Cloudscape (inferred from class name)",
    "tablesAccessed": [
      "category",
      "category_details",
      "product",
      "product_details",
      "item",
      "item_details"
    ],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "The code uses parameterized SELECT statements with joins (INNER JOIN) to fetch localized data. It includes a dynamic query builder for search functionality that constructs a WHERE clause based on the number of input keywords.",
    "transactionHandling": "Manual resource management (close() calls). No explicit transaction boundaries (commit/rollback) are defined, implying auto-commit or read-only behavior.",
    "protocol": "JDBC",
    "connectionInfo": "JNDI: java:comp/env/jdbc/CatalogDataSource",
    "codeExample": "c = getDataSource().getConnection();\nps = c.prepareStatement(GET_CATEGORY_STATEMENT,\n                        ResultSet.TYPE_SCROLL_INSENSITIVE,\n                        ResultSet.CONCUR_READ_ONLY);\nps.setString(1, l.toString());\nps.setString(2, categoryID);\nrs = ps.executeQuery();"
  },
  {
    "path": "com.sun.j2ee.blueprints.catalog.dao.GenericCatalogDAO",
    "mechanism": "JDBC",
    "name": "CatalogDataSource",
    "description": "The class uses standard JDBC APIs (Connection, PreparedStatement, ResultSet) to interact with the database. It retrieves a DataSource via JNDI lookup. SQL statements are not hardcoded in the Java file but are constructed from fragments loaded from an external XML file, allowing for dynamic query generation based on parameters.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ"
    ],
    "queryPatterns": "Dynamic SQL construction from XML fragments, primarily SELECT statements with parameter binding.",
    "transactionHandling": "Transactions are not explicitly managed within this class (no commit/rollback calls), implying auto-commit mode or container-managed transactions.",
    "protocol": "JDBC",
    "connectionInfo": "JNDI: java:comp/env/jdbc/CatalogDataSource",
    "codeExample": "connection = getDataSource().getConnection();\nString[] parameterValues = new String[] { locale.toString(), categoryID };\nstatement = buildSQLStatement(connection, sqlStatements, XML_GET_CATEGORY, parameterValues);\nresultSet = statement.executeQuery();"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "JDBC",
    "name": "ItemPopulator",
    "description": "The class interacts with the database using raw JDBC connections passed into its methods. It relies on a `PopulateUtils` helper class to execute SQL statements stored in a `Map`. It performs DDL (Create/Drop) and DML (Insert) operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "item"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Simple CRUD (Insert) and DDL (Create Table, Drop Table) operations defined externally in a Map.",
    "transactionHandling": "Manual transaction handling implied by passing the Connection object; specific commit/rollback logic is likely handled by the caller or the utility class.",
    "protocol": "JDBC",
    "connectionInfo": "Passed as java.sql.Connection parameter",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"item\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "JDBC",
    "name": "ProductPopulator",
    "description": "The class interacts with the database using standard JDBC `Connection` objects passed to its methods. It delegates the actual execution of SQL to a utility class `PopulateUtils`, which retrieves SQL templates from a `Map` based on operation keys (INSERT, CREATE, DROP, CHECK). It supports both direct execution against a database and generating SQL scripts (printing) when no connection is provided.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "product"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "The code performs DDL operations (CREATE/DROP tables) and batch-like INSERT operations driven by XML parsing. It also performs simple checks (SELECT 1 or similar) to verify table existence.",
    "transactionHandling": "Transactions are not explicitly managed within this class (no commit/rollback calls). It relies on the provided JDBC Connection's state (likely auto-commit or managed by the caller).",
    "protocol": "JDBC",
    "connectionInfo": "Passed dynamically via method parameters",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"product\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "JDBC",
    "name": "CategoryPopulator",
    "description": "The class interacts with the database using raw JDBC Connections and SQL statements provided in a Map. It uses a utility class 'PopulateUtils' to abstract the execution of PreparedStatement logic.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "category"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Simple CRUD (INSERT) and DDL (CREATE, DROP) operations defined externally in a Map.",
    "transactionHandling": "Manual transaction context implied by passing Connection objects, though explicit commit/rollback is not visible in this file.",
    "protocol": "JDBC",
    "connectionInfo": "Passed as java.sql.Connection parameter",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"category\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate",
    "mechanism": "JDBC",
    "name": "CatalogPopulator",
    "description": "The class manages database schema operations (DDL) and data verification via JDBC Connections passed to helper classes. It does not execute SQL directly but orchestrates the execution via CategoryPopulator, ProductPopulator, and ItemPopulator.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "Category",
      "Product",
      "Item"
    ],
    "operationType": [
      "DDL",
      "READ"
    ],
    "queryPatterns": "DDL operations (CREATE/DROP) and checks.",
    "transactionHandling": "Manual or Auto-commit (managed by caller providing the Connection)",
    "protocol": "JDBC",
    "connectionInfo": "Passed via method arguments",
    "codeExample": "public void createTables(Connection connection) throws PopulateException {\n    categoryPopulator.createTables(connection);\n    productPopulator.createTables(connection);\n    itemPopulator.createTables(connection);\n    return;\n  }"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.CategoryDetailsPopulator",
    "mechanism": "JDBC",
    "name": "CategoryDetailsPopulator",
    "description": "The class interacts with the database using standard JDBC connections passed to its methods. It does not contain inline SQL but retrieves SQL statements from a `Map` (likely loaded from a properties file elsewhere). It performs DDL operations (CREATE, DROP) and DML operations (INSERT) via a helper utility `PopulateUtils`.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "category_details"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Simple CRUD (Insert) and DDL (Create/Drop) operations executed via prepared statements or generic execution handlers.",
    "transactionHandling": "Manual transaction handling is implied as the Connection object is passed in, but explicit commit/rollback is not visible in this file (likely handled by the caller or PopulateUtils).",
    "protocol": "JDBC",
    "connectionInfo": "Passed as java.sql.Connection parameter",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"category_details\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.ItemDetailsPopulator",
    "mechanism": "JDBC",
    "name": "item_details",
    "description": "The class interacts with the database using raw JDBC Connections passed to its methods. It executes SQL statements (INSERT, CREATE, DROP, CHECK) stored in a Map, using a helper utility 'PopulateUtils' to handle the PreparedStatement execution.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "item_details"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Simple CRUD and DDL operations defined externally in a Map.",
    "transactionHandling": "Manual transaction handling via the passed Connection object (likely managed by the caller).",
    "protocol": "JDBC",
    "connectionInfo": "Passed as method argument 'java.sql.Connection'",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"item_details\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.PopulateServlet",
    "mechanism": "JDBC",
    "name": "CatalogDataSource",
    "description": "The servlet interacts with the database using raw JDBC connections obtained from a DataSource looked up via JNDI. It executes dynamic SQL statements (DDL for table creation and DML for data insertion) that are parsed from XML configuration files.",
    "databaseName": "cloudscape",
    "tablesAccessed": [
      "unknown (dynamic from XML)"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Dynamic SQL execution based on XML definitions, including CREATE TABLE, INSERT, DROP TABLE, and CHECK statements.",
    "transactionHandling": "Manual/Implicit (Connection obtained from DataSource, no explicit commit/rollback logic visible in this file, likely auto-commit or handled by populators)",
    "protocol": "JDBC",
    "connectionInfo": "JNDI: java:comp/env/jdbc/CatalogDataSource (inferred from JNDINames.CATALOG_DATASOURCE)",
    "codeExample": "InitialContext context = new InitialContext();\nreturn ((DataSource) context.lookup(JNDINames.CATALOG_DATASOURCE)).getConnection();"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.PopulateUtils",
    "mechanism": "JDBC",
    "name": "PopulateUtils",
    "description": "The class interacts directly with the database using the Java Database Connectivity (JDBC) API. It uses `PreparedStatement` to execute arbitrary SQL commands (CREATE, INSERT, DROP, CHECK) defined in external maps or strings.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "READ_WRITE"
    ],
    "queryPatterns": "The code executes dynamic SQL statements provided as strings. These can be DDL (create/drop) or DML (insert) operations depending on the input.",
    "transactionHandling": "The code operates on a passed `Connection` object. It does not explicitly call commit or rollback, implying that transaction management is either handled by the caller or the connection is in auto-commit mode.",
    "protocol": "RmiJdbc (inferred from private constant DATABASE_DRIVER)",
    "connectionInfo": "unknown",
    "codeExample": "PreparedStatement statement = connection.prepareStatement(sqlStatement);\nif (parameterNames != null) {\n  for (int i = 0; i < parameterNames.length; i++) {\n    String value = handler.getValue(parameterNames[i]);\n    statement.setString(i + 1, value);\n  }\n}\nstatement.execute();"
  },
  {
    "path": "com.sun.j2ee.blueprints.petstore.tools.populate.ProductDetailsPopulator",
    "mechanism": "JDBC",
    "name": "ProductDetailsPopulator",
    "description": "The class interacts with the database using raw JDBC Connections passed into its methods. It does not contain hardcoded SQL but retrieves SQL statements from a `Map` passed during construction, using keys generated by `PopulateUtils`. It performs DDL (Create, Drop) and DML (Insert) operations.",
    "databaseName": "unknown",
    "tablesAccessed": [
      "product_details"
    ],
    "operationType": [
      "READ_WRITE",
      "DDL"
    ],
    "queryPatterns": "Simple CRUD and DDL operations defined externally in a Map.",
    "transactionHandling": "Manual transaction handling is implied as the Connection is passed in from an external source; the code itself does not explicitly commit or rollback.",
    "protocol": "JDBC",
    "connectionInfo": "Passed as parameter 'connection'",
    "codeExample": "PopulateUtils.executeSQLStatement(connection, sqlStatements, PopulateUtils.makeSQLStatementKey(PopulateUtils.INSERT_OPERATION, \"product_details\"), PARAMETER_NAMES, this);"
  },
  {
    "path": "com.sun.j2ee.blueprints.servicelocator.ejb.ServiceLocator",
    "mechanism": "JDBC",
    "name": "ServiceLocator",
    "description": "The class acts as a factory to retrieve `javax.sql.DataSource` objects via JNDI lookup. It does not execute SQL itself, but it is the gateway for the application to obtain database connections managed by the application server.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "OTHER"
    ],
    "queryPatterns": "n/a",
    "transactionHandling": "unknown",
    "protocol": "JDBC",
    "connectionInfo": "JNDI lookup (name provided at runtime)",
    "codeExample": "dataSource = (DataSource)ic.lookup(dataSourceName);"
  },
  {
    "path": "com.sun.j2ee.blueprints.servicelocator.web.ServiceLocator",
    "mechanism": "JDBC",
    "name": "DataSourceFactory",
    "description": "The class acts as a factory to retrieve `javax.sql.DataSource` objects via JNDI lookup. It caches these references to optimize performance. It does not execute SQL itself, but provides the connection factory for other classes to do so.",
    "databaseName": "unknown",
    "tablesAccessed": [],
    "operationType": [
      "OTHER"
    ],
    "queryPatterns": "n/a",
    "transactionHandling": "none",
    "protocol": "JDBC",
    "connectionInfo": "JNDI Lookup",
    "codeExample": "dataSource = (DataSource)ic.lookup(dataSourceName);"
  },
  {
    "path": "dbstuff/forall-inserts-comparison.sql",
    "mechanism": "STORED-PROCEDURE",
    "name": "Oracle PL/SQL Benchmark",
    "description": "The code is a native Oracle PL/SQL script that integrates directly with the database engine. It defines Data Definition Language (DDL) objects including tables and types, and uses a Stored Procedure to execute Data Manipulation Language (DML) operations. The integration leverages high-performance features such as Bulk Collect, FORALL, and Direct Path Inserts (via hints) to interact with the defined tables.",
    "databaseName": "Oracle",
    "tablesAccessed": [
      "parts",
      "parts2"
    ],
    "operationType": [
      "READ",
      "WRITE",
      "DDL"
    ],
    "queryPatterns": "The code uses simple INSERTs, Bulk INSERTs (FORALL), INSERT SELECT from TABLE() casts, and Dynamic SQL for TRUNCATE operations.",
    "transactionHandling": "The code explicitly manages transactions using COMMIT and ROLLBACK statements to reset table states between performance tests.",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "FORALL indx IN 1 .. num\n   INSERT INTO parts\n       VALUES (pnums (indx), pnames (indx) \n              );\n\nshow_elapsed_time ('FORALL (bulk)' || num);"
  },
  {
    "path": "dbstuff/forall-bulk-rowcount.sql",
    "mechanism": "STORED-PROCEDURE",
    "name": "Oracle PL/SQL Bulk Processing",
    "description": "The code relies entirely on Oracle PL/SQL specific features. It integrates via stored procedures and anonymous blocks using bulk processing commands (`FORALL`, `BULK COLLECT`) to optimize database round-trips. It employs Dynamic SQL (`EXECUTE IMMEDIATE`) for schema changes and data insertion. It interacts with the `employees` table for updates and manages the lifecycle of the `empno_temp` table.",
    "databaseName": "Oracle",
    "tablesAccessed": [
      "employees",
      "empno_temp"
    ],
    "operationType": [
      "READ",
      "WRITE",
      "DDL"
    ],
    "queryPatterns": "Bulk UPDATE with RETURNING clause, Dynamic CREATE/DROP TABLE, Dynamic INSERT with bind variables",
    "transactionHandling": "Explicit COMMIT/ROLLBACK and PRAGMA AUTONOMOUS_TRANSACTION",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "FORALL indx IN 1 .. n_in.COUNT\n   EXECUTE IMMEDIATE 'insert into empno_temp values (:empno)'\n      USING n_in (indx);\nCOMMIT;"
  },
  {
    "path": "dbstuff/cursors-in-plsql.sql",
    "mechanism": "STORED-PROCEDURE",
    "name": "Oracle PL/SQL Cursors",
    "description": "The code relies entirely on Oracle PL/SQL for database integration. It performs DDL to define schema objects and DML to manipulate data. It extensively uses stored procedures, packages, and anonymous blocks to interact with the database using various cursor mechanisms (Implicit, Explicit, REF CURSOR) and dynamic SQL methods (DBMS_SQL, EXECUTE IMMEDIATE patterns via OPEN FOR).",
    "databaseName": "Oracle Database",
    "tablesAccessed": [
      "endangered_species",
      "hr.locations",
      "hr.departments",
      "hr.employees"
    ],
    "operationType": [
      "READ",
      "WRITE",
      "DDL"
    ],
    "queryPatterns": "The code demonstrates multiple patterns: simple SELECT INTO, BULK COLLECT for batch retrieval, explicit CURSOR declaration and iteration, dynamic SQL using OPEN FOR, and low-level dynamic SQL using DBMS_SQL.",
    "transactionHandling": "Explicit COMMIT is used after the initial data insertion; otherwise, read operations do not explicitly manage transactions.",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "CURSOR species_cur (filter_in IN VARCHAR2) \nIS \n     SELECT * \n       FROM endangered_species \n      WHERE species_name LIKE filter_in;"
  },
  {
    "path": "dbstuff/cursor-for-loop.sql",
    "mechanism": "STORED-PROCEDURE",
    "name": "emps_pkg",
    "description": "The code integrates with an Oracle database using PL/SQL scripts and DDL. It defines a stored package ('emps_pkg') and executes anonymous blocks to manage data retrieval via cursors. The integration relies on standard SQL queries embedded within PL/SQL constructs to access the 'employees' table.",
    "databaseName": "Oracle Database",
    "tablesAccessed": [
      "employees"
    ],
    "operationType": [
      "READ",
      "DDL"
    ],
    "queryPatterns": "The code uses 'SELECT *' queries within cursor definitions, including parameterized WHERE clauses.",
    "transactionHandling": "No explicit transaction control (COMMIT/ROLLBACK) is used as the operations are read-only or DDL (which auto-commits).",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "CURSOR emps_cur (department_id_in IN INTEGER) \nIS \n   SELECT * FROM employees \n    WHERE department_id = department_id_in;"
  },
  {
    "path": "dbstuff/cursor-for-loop-optimization.sql",
    "mechanism": "STORED-PROCEDURE",
    "name": "test_cursor_performance",
    "description": "The file defines a PL/SQL stored procedure that interacts with the Oracle database engine. It uses SELECT queries on the system table 'dual' to generate data. It also includes DDL statements (ALTER PROCEDURE) to modify compiler settings and anonymous PL/SQL blocks to execute the procedure.",
    "databaseName": "Oracle",
    "tablesAccessed": [
      "dual"
    ],
    "operationType": [
      "READ",
      "DDL",
      "ADMIN"
    ],
    "queryPatterns": "CONNECT BY LEVEL generation, Cursor iteration, BULK COLLECT, ALTER PROCEDURE statements",
    "transactionHandling": "None (Read-only logic)",
    "protocol": "Oracle PL/SQL",
    "connectionInfo": "not applicable for SQL files",
    "codeExample": "CURSOR cur IS \n   SELECT * FROM dual \n   CONNECT BY LEVEL < 100001; \nFETCH cur BULK COLLECT INTO many_rows LIMIT 100;\nALTER PROCEDURE test_cursor_performance COMPILE plsql_optimize_level=2;"
  },
  {
    "path": "dbstuff/trigger-predicates.sql",
    "mechanism": "TRIGGER",
    "name": "Oracle PL/SQL Triggers and Procedures",
    "description": "The code utilizes Oracle PL/SQL to define database triggers that respond to DML events (INSERT, UPDATE, DELETE). It integrates DDL for table creation, Stored Procedures for shared logic, and Triggers for event interception. The logic relies on Oracle-specific conditional predicates to determine the operation type dynamically.",
    "databaseName": "Oracle Database",
    "tablesAccessed": [
      "employees"
    ],
    "operationType": [
      "DDL",
      "READ",
      "WRITE"
    ],
    "queryPatterns": "The script uses CREATE TABLE for schema definition, standard INSERT/UPDATE/DELETE statements for data manipulation, and PL/SQL blocks for logic.",
    "transactionHandling": "Explicit COMMIT is used in the initial data setup block; other operations rely on the session's transaction state.",
    "protocol": "Oracle PL/SQL 12c+",
    "codeExample": "CREATE OR REPLACE TRIGGER employee_changes_after \n   AFTER UPDATE OR INSERT  \n   ON employees  \nBEGIN  \n   show_trigger_event;  \nEND;"
  }
]