recordingdb.properties

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

##########################################################
# Properties to map Recording objects 
# to an Oracle database

####################
# These properties define the connection

DataMapperClass=org.jlf.dataMap.jdbcMap.JDBCDataMapper

ConnectionProperties.DriverClass=oracle.jdbc.driver.OracleDriver
ConnectionProperties.DatabaseURL=jdbc:oracle:thin:@dbserver:1521:database
ConnectionProperties.user=scott
ConnectionProperties.password=tiger


##########################################################
# Recording class data mapping

# SQL statements to create a recording
Recording.criteriaKey.createStatement.sqlStatement=\
    insert into RECORDINGS ( \
        RECORDING_ID, \
        RECORDING_TITLE, \
        RECORDING_ARTIST, \
        CATALOG_NUMBER, \
        LIST_PRICE, \
        VERSION) \
    values ( \
        RECORDINGS_SEQ.NEXTVAL, \
        {RECORDING_TITLE}, \
        {RECORDING_ARTIST}, \
        {CATALOG_NUMBER}, \
        {LIST_PRICE}, \
        {VERSION} )
        
Recording.criteriaKey.createStatement2.sqlStatement=\
    select RECORDINGS_SEQ.CURRVAL as RECORDING_ID \
      from DUAL
Recording.criteriaKey.createStatement2.isQuery=true
     
# SQL statement for a "findByPrimaryKey" search criteria
Recording.criteriaKey.findByPrimaryKey.sqlStatement=\
    select * \
      from RECORDINGS \
     where RECORDING_ID = {RECORDING_ID}

# SQL statement for a "findByTitle" search criteria
Recording.criteriaKey.findByTitle.sqlStatement=\
    select * \
      from RECORDINGS \
     where RECORDING_TITLE like {RECORDING_TITLE}

# SQL statement for a "findByArtist" search criteria
Recording.criteriaKey.findByArtist.sqlStatement=\
    select * \
      from RECORDINGS \
     where RECORDING_ARTIST like {RECORDING_ARTIST}

# SQL statement to optimistic lock a recording
Recording.criteriaKey.optimisticLockingStatement.sqlStatement=\
    select VERSION \
      from RECORDINGS \
     where RECORDING_ID = {RECORDING_ID} \
       and VERSION = {VERSION}

# SQL statement to update a recording
Recording.criteriaKey.updateStatement.sqlStatement=\
    update RECORDINGS set \
        RECORDING_TITLE = {RECORDING_TITLE}, \
        RECORDING_ARTIST = {RECORDING_ARTIST}, \
        CATALOG_NUMBER = {CATALOG_NUMBER}, \
        LIST_PRICE = {LIST_PRICE}, \
        VERSION = VERSION + 1 \
    where RECORDING_ID = {RECORDING_ID}

# Retrieves the reset VERSION
Recording.criteriaKey.updateStatement2.sqlStatement=\
    select VERSION \
      from RECORDINGS \
     where RECORDING_ID = {RECORDING_ID}
Recording.criteriaKey.updateStatement2.isQuery=true
     
# SQL statement to delete a recording
Recording.criteriaKey.deleteStatement.sqlStatement=\
    delete from RECORDINGS \
          where RECORDING_ID = {RECORDING_ID}

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



##########################################################
# CustomerType class data mapping

# SQL statement for a "findByPrimaryKey" search criteria
CustomerType.criteriaKey.findByPrimaryKey.sqlStatement=\
    select * \
      from CUSTOMER_TYPE \
     where CUSTOMER_TYPE_ID = {CUSTOMER_TYPE_ID}

# SQL statement for a "findAll" search criteria
CustomerType.criteriaKey.findAll.sqlStatement=\
    select * \
      from CUSTOMER_TYPE


##########################################################
# CustomerTrackingType class data mapping

# SQL statement for a "findByPrimaryKey" search criteria
CustomerTrackingType.criteriaKey.findByPrimaryKey.sqlStatement=\
    select * \
      from CUSTOMER_TRACKING_TYPE \
     where TRACKING_TYPE_ID = {TRACKING_TYPE_ID}

# SQL statement for a "findAll" search criteria
CustomerTrackingType.criteriaKey.findAll.sqlStatement=\
    select * \
      from CUSTOMER_TRACKING_TYPE


##########################################################
# Customer class data mapping

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

# SQL statement for a "findByNickname" search criteria
Customer.criteriaKey.findByNickname.sqlStatement=\
    select * \
      from CUSTOMERS \
     where NICKNAME like {NICKNAME}

# SQL statement for a "findByEmailAddress" search criteria
Customer.criteriaKey.findByEmailAddress.sqlStatement=\
    select * \
      from CUSTOMERS \
     where EMAIL_ADDRESS like {EMAIL_ADDRESS}

# SQL statement to find customers by tracking criteria
Customer.criteriaKey.findByTrackingCriteria.sqlStatement=\
select distinct c.CUSTOMER_ID, \
       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 \
  from RECORDINGS r, \
	   CUSTOMER_TRACKED_RECORDINGS ctr, \
       CUSTOMERS c \
 where r.RECORDING_ARTIST like {customerTrackedRecordings.recording.RECORDING_ARTIST} \
   and r.RECORDING_TITLE like {customerTrackedRecordings.recording.RECORDING_TITLE} \
   and r.RECORDING_ID = ctr.RECORDING_ID \
   and ctr.TRACKING_TYPE_ID = {customerTrackedRecordings.customerTrackingType.TRACKING_TYPE_ID} \
   and ctr.CUSTOMER_ID = c.CUSTOMER_ID

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

# SQL statement to update a customer
Customer.criteriaKey.updateStatement.sqlStatement=\
    update CUSTOMERS set \
        NICKNAME = {NICKNAME}, \
        EMAIL_ADDRESS = {EMAIL_ADDRESS}, \
        VERSION = VERSION + 1 \
    where CUSTOMER_ID = {CUSTOMER_ID}

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

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


##########################################################
# FrequentBuyer class data mapping

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

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

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

# Retrieves the reset VERSION
FrequentBuyer.criteriaKey.updateStatement2.sqlStatement=\
    select VERSION \
      from CUSTOMERS \