recordingdb.properties

此程序都是企业级 的数据库开发程序 全面揭示了JAVA对数据库的操作

     where CUSTOMER_ID = {CUSTOMER_ID}
FrequentBuyer.criteriaKey.updateStatement2.isQuery=true
     
# SQL statement to delete a frequent buyer
FrequentBuyer.criteriaKey.deleteStatement.sqlStatement=\
    delete from CUSTOMERS \
          where CUSTOMER_ID = {CUSTOMER_ID}

# Define relationship between FrequentBuyer and CustomerTrackedRecording objects
FrequentBuyer.relationship.customerTrackedRecordings.lazyReadRelationship=true


##########################################################
# Corporation class data mapping

# SQL statements to create a corporation
Corporation.criteriaKey.createStatement.sqlStatement=\
    insert into CUSTOMERS ( \
        CUSTOMER_ID, \
        CUSTOMER_TYPE_ID, \
        NICKNAME, \
        EMAIL_ADDRESS, \
        NAME, \
        COMPANY_NAME, \
        ADDRESS, \
        CITY, \
        STATE, \
        ZIPCODE, \
        VERSION) \
    values ( \
        CUSTOMERS_SEQ.NEXTVAL, \
        {CUSTOMER_TYPE_ID}, \
        {NICKNAME}, \
        {EMAIL_ADDRESS}, \
        {NAME}, \
        {COMPANY_NAME}, \
        {ADDRESS}, \
        {CITY}, \
        {STATE}, \
        {ZIPCODE}, \
        {VERSION} )
        
Corporation.criteriaKey.createStatement2.sqlStatement=\
    select CUSTOMERS_SEQ.CURRVAL as CUSTOMER_ID \
      from DUAL
Corporation.criteriaKey.createStatement2.isQuery=true
     
# SQL statement for a "findByPrimaryKey" search criteria
Corporation.criteriaKey.findByPrimaryKey.sqlStatement=\
    select * \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID}

# SQL statement to optimistic lock a corporation
Corporation.criteriaKey.optimisticLockingStatement.sqlStatement=\
    select VERSION \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID} \
       and VERSION = {VERSION}

# SQL statement to update a corporation
Corporation.criteriaKey.updateStatement.sqlStatement=\
    update CUSTOMERS set \
        NICKNAME = {NICKNAME}, \
        EMAIL_ADDRESS = {EMAIL_ADDRESS}, \
        NAME = {NAME}, \
        COMPANY_NAME = {COMPANY_NAME}, \
        ADDRESS = {ADDRESS}, \
        CITY = {CITY}, \
        STATE = {STATE}, \
        ZIPCODE = {ZIPCODE}, \
        VERSION = VERSION + 1 \
    where CUSTOMER_ID = {CUSTOMER_ID}

# Retrieves the reset VERSION
Corporation.criteriaKey.updateStatement2.sqlStatement=\
    select VERSION \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID}
Corporation.criteriaKey.updateStatement2.isQuery=true
     
# SQL statement to delete a corporation
Corporation.criteriaKey.deleteStatement.sqlStatement=\
    delete from CUSTOMERS \
          where CUSTOMER_ID = {CUSTOMER_ID}

# Define relationship between Corporation and CustomerTrackedRecording objects
Corporation.relationship.customerTrackedRecordings.lazyReadRelationship=true


##########################################################
# NonProfitCorporation class data mapping

# SQL statements to create a non-profit
NonProfitCorporation.criteriaKey.createStatement.sqlStatement=\
    insert into CUSTOMERS ( \
        CUSTOMER_ID, \
        CUSTOMER_TYPE_ID, \
        NICKNAME, \
        EMAIL_ADDRESS, \
        NAME, \
        COMPANY_NAME, \
        ADDRESS, \
        CITY, \
        STATE, \
        ZIPCODE, \
        TAX_EXEMPT_ID, \
        VERSION) \
    values ( \
        CUSTOMERS_SEQ.NEXTVAL, \
        {CUSTOMER_TYPE_ID}, \
        {NICKNAME}, \
        {EMAIL_ADDRESS}, \
        {NAME}, \
        {COMPANY_NAME}, \
        {ADDRESS}, \
        {CITY}, \
        {STATE}, \
        {ZIPCODE}, \
        {TAX_EXEMPT_ID}, \
        {VERSION} )
        
NonProfitCorporation.criteriaKey.createStatement2.sqlStatement=\
    select CUSTOMERS_SEQ.CURRVAL as CUSTOMER_ID \
      from DUAL
NonProfitCorporation.criteriaKey.createStatement2.isQuery=true
     
# SQL statement for a "findByPrimaryKey" search criteria
NonProfitCorporation.criteriaKey.findByPrimaryKey.sqlStatement=\
    select * \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID}

# SQL statement to optimistic lock a non-profit
NonProfitCorporation.criteriaKey.optimisticLockingStatement.sqlStatement=\
    select VERSION \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID} \
       and VERSION = {VERSION}

# SQL statement to update a non-profit
NonProfitCorporation.criteriaKey.updateStatement.sqlStatement=\
    update CUSTOMERS set \
        NICKNAME = {NICKNAME}, \
        EMAIL_ADDRESS = {EMAIL_ADDRESS}, \
        NAME = {NAME}, \
        COMPANY_NAME = {COMPANY_NAME}, \
        ADDRESS = {ADDRESS}, \
        CITY = {CITY}, \
        STATE = {STATE}, \
        ZIPCODE = {ZIPCODE}, \
        TAX_EXEMPT_ID = {TAX_EXEMPT_ID}, \
        VERSION = VERSION + 1 \
    where CUSTOMER_ID = {CUSTOMER_ID}

# Retrieves the reset VERSION
NonProfitCorporation.criteriaKey.updateStatement2.sqlStatement=\
    select VERSION \
      from CUSTOMERS \
     where CUSTOMER_ID = {CUSTOMER_ID}
NonProfitCorporation.criteriaKey.updateStatement2.isQuery=true
     
# SQL statement to delete a non-profit
NonProfitCorporation.criteriaKey.deleteStatement.sqlStatement=\
    delete from CUSTOMERS \
          where CUSTOMER_ID = {CUSTOMER_ID}

# Define relationship between NonProfitCorporation and CustomerTrackedRecording objects
NonProfitCorporation.relationship.customerTrackedRecordings.lazyReadRelationship=true


##########################################################
# CustomerTrackedRecording class data mapping

# SQL statements to create a tracking relationship
CustomerTrackedRecording.criteriaKey.createStatement.sqlStatement=\
    insert into CUSTOMER_TRACKED_RECORDINGS ( \
        CUSTOMER_ID, \
        RECORDING_ID, \
        TRACKING_TYPE_ID, \
        DATE_TRACKED, \
        VERSION) \
    values ( \
        {customer.CUSTOMER_ID}, \
        {recording.RECORDING_ID}, \
        {customerTrackingType.TRACKING_TYPE_ID}, \
        to_date({DATE_TRACKED}, 'MM/DD/YYYY HH24:MI:SS'), \
        {VERSION} )
        
CustomerTrackedRecording.criteriaKey.createStatement2.sqlStatement=\
    select CUSTOMER_ID, RECORDING_ID, TRACKING_TYPE_ID \
      from CUSTOMER_TRACKED_RECORDINGS \
     where CUSTOMER_ID = {customer.CUSTOMER_ID} \
       and RECORDING_ID = {recording.RECORDING_ID} \
       and TRACKING_TYPE_ID = {customerTrackingType.TRACKING_TYPE_ID}

CustomerTrackedRecording.criteriaKey.createStatement2.isQuery=true
        
# SQL statement for a "findByCustomer" search criteria
CustomerTrackedRecording.criteriaKey.findByCustomer.sqlStatement=\
    select ctr.RECORDING_ID, ctr.TRACKING_TYPE_ID, ctr.CUSTOMER_ID, \
           ctr.DATE_TRACKED, ctr.VERSION, \
           c.NICKNAME, c.EMAIL_ADDRESS, c.CUSTOMER_TYPE_ID, \
           c.NAME, c.ADDRESS, c.CITY, c.STATE, c.ZIPCODE, \
           c.COMPANY_NAME, c.TAX_EXEMPT_ID, c.VERSION as CUST_VERSION, \
           r.RECORDING_TITLE, r.RECORDING_ARTIST, r.CATALOG_NUMBER, \
           r.LIST_PRICE, r.VERSION as REC_VERSION \
      from CUSTOMER_TRACKED_RECORDINGS ctr, \
           CUSTOMERS c, \
           RECORDINGS r \
     where ctr.CUSTOMER_ID = {customer.CUSTOMER_ID} \
       and r.RECORDING_ID = ctr.RECORDING_ID \
       and c.CUSTOMER_ID = ctr.CUSTOMER_ID

# SQL statement for a "findByRecording" search criteria
CustomerTrackedRecording.criteriaKey.findByRecording.sqlStatement=\
    select ctr.RECORDING_ID, ctr.TRACKING_TYPE_ID, ctr.CUSTOMER_ID, \
           ctr.DATE_TRACKED, ctr.VERSION, \
           c.NICKNAME, c.EMAIL_ADDRESS, c.CUSTOMER_TYPE_ID, \
           c.NAME, c.ADDRESS, c.CITY, c.STATE, c.ZIPCODE, \
           c.COMPANY_NAME, c.TAX_EXEMPT_ID, c.VERSION as CUST_VERSION, \
           r.RECORDING_TITLE, r.RECORDING_ARTIST, r.CATALOG_NUMBER, \
           r.LIST_PRICE, r.VERSION as REC_VERSION \
      from CUSTOMER_TRACKED_RECORDINGS ctr, \
           CUSTOMERS c, \
           RECORDINGS r \
     where ctr.RECORDING_ID = {recording.RECORDING_ID} \
       and r.RECORDING_ID = ctr.RECORDING_ID \
       and c.CUSTOMER_ID = ctr.CUSTOMER_ID

# SQL statement to optimistic lock a tracking relationship
CustomerTrackedRecording.criteriaKey.optimisticLockingStatement.sqlStatement=\
    select VERSION \
      from CUSTOMER_TRACKED_RECORDINGS \
     where CUSTOMER_ID = {CUSTOMER_ID} \
       and RECORDING_ID = {RECORDING_ID} \
       and TRACKING_TYPE_ID = {TRACKING_TYPE_ID} \
       and VERSION = {VERSION}

# SQL statement to update a tracking relationship
CustomerTrackedRecording.criteriaKey.updateStatement.sqlStatement=\
    update CUSTOMER_TRACKED_RECORDINGS set \
        DATE_TRACKED = to_date({DATE_TRACKED}, 'MM/DD/YYYY HH24:MI:SS'), \
        VERSION = VERSION + 1 \
    where CUSTOMER_ID = {CUSTOMER_ID} \
      and RECORDING_ID = {RECORDING_ID} \
      and TRACKING_TYPE_ID = {TRACKING_TYPE_ID}

# Retrieves the reset VERSION
CustomerTrackedRecording.criteriaKey.updateStatement2.sqlStatement=\
    select VERSION \
      from CUSTOMER_TRACKED_RECORDINGS \
    where CUSTOMER_ID = {CUSTOMER_ID} \
      and RECORDING_ID = {RECORDING_ID} \
      and TRACKING_TYPE_ID = {TRACKING_TYPE_ID}
CustomerTrackedRecording.criteriaKey.updateStatement2.isQuery=true
     
# SQL statement to delete a tracking relationship
CustomerTrackedRecording.criteriaKey.deleteStatement.sqlStatement=\
    delete from CUSTOMER_TRACKED_RECORDINGS \
    where CUSTOMER_ID = {CUSTOMER_ID} \
      and RECORDING_ID = {RECORDING_ID} \
      and TRACKING_TYPE_ID = {TRACKING_TYPE_ID}

# Define relationships to CustomerTrackedRecording objects
CustomerTrackedRecording.relationship.customer.readRelationshipInSameQuery=true
CustomerTrackedRecording.relationship.recording.readRelationshipInSameQuery=true

CustomerTrackedRecording.relationship.recording.attributeAlias.VERSION=REC_VERSION
CustomerTrackedRecording.relationship.customer.attributeAlias.VERSION=CUST_VERSION