Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.liferay.portal.service.persistence.impl.TableMapperImpl Maven / Gradle / Ivy
/**
* Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*/
package com.liferay.portal.service.persistence.impl;
import com.liferay.portal.NoSuchModelException;
import com.liferay.portal.kernel.cache.MultiVMPoolUtil;
import com.liferay.portal.kernel.cache.PortalCache;
import com.liferay.portal.kernel.dao.jdbc.MappingSqlQuery;
import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
import com.liferay.portal.kernel.dao.jdbc.RowMapper;
import com.liferay.portal.kernel.dao.jdbc.SqlUpdate;
import com.liferay.portal.kernel.dao.jdbc.SqlUpdateFactoryUtil;
import com.liferay.portal.kernel.exception.SystemException;
import com.liferay.portal.kernel.util.ListUtil;
import com.liferay.portal.kernel.util.OrderByComparator;
import com.liferay.portal.model.BaseModel;
import com.liferay.portal.model.ModelListener;
import com.liferay.portal.service.persistence.BasePersistence;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import javax.sql.DataSource;
/**
* @author Shuyang Zhou
*/
public class TableMapperImpl, R extends BaseModel>
implements TableMapper {
public TableMapperImpl(
String tableName, String leftColumnName, String rightColumnName,
BasePersistence leftBasePersistence,
BasePersistence rightBasePersistence) {
this.leftColumnName = leftColumnName;
this.rightColumnName = rightColumnName;
this.leftBasePersistence = leftBasePersistence;
this.rightBasePersistence = rightBasePersistence;
DataSource dataSource = leftBasePersistence.getDataSource();
addTableMappingSqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(
dataSource,
"INSERT INTO " + tableName + " (" + leftColumnName + ", " +
rightColumnName + ") VALUES (?, ?)",
new int[] {Types.BIGINT, Types.BIGINT});
deleteLeftPrimaryKeyTableMappingsSqlUpdate =
SqlUpdateFactoryUtil.getSqlUpdate(
dataSource,
"DELETE FROM " + tableName + " WHERE " + leftColumnName +
" = ?",
new int[] {Types.BIGINT});
deleteRightPrimaryKeyTableMappingsSqlUpdate =
SqlUpdateFactoryUtil.getSqlUpdate(
dataSource,
"DELETE FROM " + tableName + " WHERE " + rightColumnName +
" = ?",
new int[] {Types.BIGINT});
deleteTableMappingSqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(
dataSource,
"DELETE FROM " + tableName + " WHERE " + leftColumnName +
" = ? AND " + rightColumnName + " = ?",
new int[] {Types.BIGINT, Types.BIGINT});
getLeftPrimaryKeysSqlQuery =
MappingSqlQueryFactoryUtil.getMappingSqlQuery(
dataSource,
"SELECT " + leftColumnName + " FROM " + tableName + " WHERE " +
rightColumnName + " = ?",
new int[] {Types.BIGINT}, RowMapper.PRIMARY_KEY);
getRightPrimaryKeysSqlQuery =
MappingSqlQueryFactoryUtil.getMappingSqlQuery(
dataSource,
"SELECT " + rightColumnName + " FROM " + tableName + " WHERE " +
leftColumnName + " = ?",
new int[] {Types.BIGINT}, RowMapper.PRIMARY_KEY);
leftToRightPortalCache = MultiVMPoolUtil.getCache(
TableMapper.class.getName() + "-" + tableName + "-LeftToRight");
rightToLeftPortalCache = MultiVMPoolUtil.getCache(
TableMapper.class.getName() + "-" + tableName + "-RightToLeft");
}
@Override
public boolean addTableMapping(long leftPrimaryKey, long rightPrimaryKey)
throws SystemException {
if (containsTableMapping(leftPrimaryKey, rightPrimaryKey, false)) {
return false;
}
leftToRightPortalCache.remove(leftPrimaryKey);
rightToLeftPortalCache.remove(rightPrimaryKey);
Class rightModelClass = rightBasePersistence.getModelClass();
ModelListener[] leftModelListeners =
leftBasePersistence.getListeners();
for (ModelListener leftModelListener : leftModelListeners) {
leftModelListener.onBeforeAddAssociation(
leftPrimaryKey, rightModelClass.getName(), rightPrimaryKey);
}
Class leftModelClass = leftBasePersistence.getModelClass();
ModelListener[] rightModelListeners =
rightBasePersistence.getListeners();
for (ModelListener rightModelListener : rightModelListeners) {
rightModelListener.onBeforeAddAssociation(
rightPrimaryKey, leftModelClass.getName(), leftPrimaryKey);
}
try {
addTableMappingSqlUpdate.update(leftPrimaryKey, rightPrimaryKey);
}
catch (Exception e) {
throw new SystemException(e);
}
for (ModelListener leftModelListener : leftModelListeners) {
leftModelListener.onAfterAddAssociation(
leftPrimaryKey, rightModelClass.getName(), rightPrimaryKey);
}
for (ModelListener rightModelListener : rightModelListeners) {
rightModelListener.onAfterAddAssociation(
rightPrimaryKey, leftModelClass.getName(), leftPrimaryKey);
}
return true;
}
@Override
public boolean containsTableMapping(
long leftPrimaryKey, long rightPrimaryKey)
throws SystemException {
return containsTableMapping(leftPrimaryKey, rightPrimaryKey, true);
}
@Override
public int deleteLeftPrimaryKeyTableMappings(long leftPrimaryKey)
throws SystemException {
return deleteTableMappings(
leftBasePersistence, rightBasePersistence, leftToRightPortalCache,
rightToLeftPortalCache, getRightPrimaryKeysSqlQuery,
deleteLeftPrimaryKeyTableMappingsSqlUpdate, leftPrimaryKey);
}
@Override
public int deleteRightPrimaryKeyTableMappings(long rightPrimaryKey)
throws SystemException {
return deleteTableMappings(
rightBasePersistence, leftBasePersistence, rightToLeftPortalCache,
leftToRightPortalCache, getLeftPrimaryKeysSqlQuery,
deleteRightPrimaryKeyTableMappingsSqlUpdate, rightPrimaryKey);
}
@Override
public boolean deleteTableMapping(long leftPrimaryKey, long rightPrimaryKey)
throws SystemException {
if (!containsTableMapping(leftPrimaryKey, rightPrimaryKey, false)) {
return false;
}
leftToRightPortalCache.remove(leftPrimaryKey);
rightToLeftPortalCache.remove(rightPrimaryKey);
Class rightModelClass = rightBasePersistence.getModelClass();
ModelListener[] leftModelListeners =
leftBasePersistence.getListeners();
for (ModelListener leftModelListener : leftModelListeners) {
leftModelListener.onBeforeRemoveAssociation(
leftPrimaryKey, rightModelClass.getName(), rightPrimaryKey);
}
Class leftModelClass = leftBasePersistence.getModelClass();
ModelListener[] rightModelListeners =
rightBasePersistence.getListeners();
for (ModelListener rightModelListener : rightModelListeners) {
rightModelListener.onBeforeRemoveAssociation(
rightPrimaryKey, leftModelClass.getName(), leftPrimaryKey);
}
int rowCount = 0;
try {
rowCount = deleteTableMappingSqlUpdate.update(
leftPrimaryKey, rightPrimaryKey);
}
catch (Exception e) {
throw new SystemException(e);
}
if (rowCount > 0) {
for (ModelListener leftModelListener : leftModelListeners) {
leftModelListener.onAfterRemoveAssociation(
leftPrimaryKey, rightModelClass.getName(), rightPrimaryKey);
}
for (ModelListener rightModelListener : rightModelListeners) {
rightModelListener.onAfterRemoveAssociation(
rightPrimaryKey, leftModelClass.getName(), leftPrimaryKey);
}
return true;
}
return false;
}
@Override
public List getLeftBaseModels(
long rightPrimaryKey, int start, int end, OrderByComparator obc)
throws SystemException {
return getBaseModels(
rightToLeftPortalCache, getLeftPrimaryKeysSqlQuery, rightPrimaryKey,
leftBasePersistence, start, end, obc);
}
@Override
public long[] getLeftPrimaryKeys(long rightPrimaryKey)
throws SystemException {
return getPrimaryKeys(
rightToLeftPortalCache, getLeftPrimaryKeysSqlQuery, rightPrimaryKey,
true);
}
@Override
public TableMapper getReverseTableMapper() {
return reverseTableMapper;
}
@Override
public List getRightBaseModels(
long leftPrimaryKey, int start, int end, OrderByComparator obc)
throws SystemException {
return getBaseModels(
leftToRightPortalCache, getRightPrimaryKeysSqlQuery, leftPrimaryKey,
rightBasePersistence, start, end, obc);
}
@Override
public long[] getRightPrimaryKeys(long leftPrimaryKey)
throws SystemException {
return getPrimaryKeys(
leftToRightPortalCache, getRightPrimaryKeysSqlQuery, leftPrimaryKey,
true);
}
@Override
public boolean matches(String leftColumnName, String rightColumnName) {
if (this.leftColumnName.equals(leftColumnName) &&
this.rightColumnName.equals(rightColumnName)) {
return true;
}
return false;
}
public void setReverseTableMapper(TableMapper reverseTableMapper) {
this.reverseTableMapper = reverseTableMapper;
}
protected static , S extends BaseModel> int
deleteTableMappings(
BasePersistence masterBasePersistence,
BasePersistence slaveBasePersistence,
PortalCache masterToSlavePortalCache,
PortalCache slaveToMasterPortalCache,
MappingSqlQuery mappingSqlQuery, SqlUpdate deleteSqlUpdate,
long masterPrimaryKey)
throws SystemException {
ModelListener[] masterModelListeners =
masterBasePersistence.getListeners();
ModelListener[] slaveModelListeners =
slaveBasePersistence.getListeners();
long[] slavePrimaryKeys = getPrimaryKeys(
masterToSlavePortalCache, mappingSqlQuery, masterPrimaryKey, false);
Class masterModelClass = null;
Class slaveModelClass = null;
if ((masterModelListeners.length > 0) ||
(slaveModelListeners.length > 0)) {
masterModelClass = masterBasePersistence.getModelClass();
slaveModelClass = slaveBasePersistence.getModelClass();
for (long slavePrimaryKey : slavePrimaryKeys) {
for (ModelListener masterModelListener :
masterModelListeners) {
masterModelListener.onBeforeRemoveAssociation(
masterPrimaryKey, slaveModelClass.getName(),
slavePrimaryKey);
}
for (ModelListener slaveModelListener :
slaveModelListeners) {
slaveModelListener.onBeforeRemoveAssociation(
slavePrimaryKey, masterModelClass.getName(),
masterPrimaryKey);
}
}
}
masterToSlavePortalCache.remove(masterPrimaryKey);
for (long slavePrimaryKey : slavePrimaryKeys) {
slaveToMasterPortalCache.remove(slavePrimaryKey);
}
int rowCount = 0;
try {
rowCount = deleteSqlUpdate.update(masterPrimaryKey);
}
catch (Exception e) {
throw new SystemException(e);
}
if ((masterModelListeners.length > 0) ||
(slaveModelListeners.length > 0)) {
for (long slavePrimaryKey : slavePrimaryKeys) {
for (ModelListener masterModelListener :
masterModelListeners) {
masterModelListener.onAfterRemoveAssociation(
masterPrimaryKey, slaveModelClass.getName(),
slavePrimaryKey);
}
for (ModelListener slaveModelListener :
slaveModelListeners) {
slaveModelListener.onAfterRemoveAssociation(
slavePrimaryKey, masterModelClass.getName(),
masterPrimaryKey);
}
}
}
return rowCount;
}
protected static > List
getBaseModels(
PortalCache portalCache,
MappingSqlQuery mappingSqlQuery, long masterPrimaryKey,
BasePersistence slaveBasePersistence, int start, int end,
OrderByComparator obc)
throws SystemException {
long[] slavePrimaryKeys = getPrimaryKeys(
portalCache, mappingSqlQuery, masterPrimaryKey, true);
if (slavePrimaryKeys.length == 0) {
return Collections.emptyList();
}
List slaveBaseModels = new ArrayList(slavePrimaryKeys.length);
try {
for (long slavePrimaryKey : slavePrimaryKeys) {
slaveBaseModels.add(
slaveBasePersistence.findByPrimaryKey(slavePrimaryKey));
}
}
catch (NoSuchModelException nsme) {
throw new SystemException(nsme);
}
if (obc != null) {
Collections.sort(slaveBaseModels, obc);
}
return ListUtil.subList(slaveBaseModels, start, end);
}
protected static long[] getPrimaryKeys(
PortalCache portalCache,
MappingSqlQuery mappingSqlQuery, long masterPrimaryKey,
boolean updateCache)
throws SystemException {
long[] primaryKeys = portalCache.get(masterPrimaryKey);
if (primaryKeys == null) {
List primaryKeysList = null;
try {
primaryKeysList = mappingSqlQuery.execute(masterPrimaryKey);
}
catch (Exception e) {
throw new SystemException(e);
}
primaryKeys = new long[primaryKeysList.size()];
for (int i = 0; i < primaryKeys.length; i++) {
primaryKeys[i] = primaryKeysList.get(i);
}
Arrays.sort(primaryKeys);
if (updateCache) {
portalCache.put(masterPrimaryKey, primaryKeys);
}
}
return primaryKeys;
}
protected boolean containsTableMapping(
long leftPrimaryKey, long rightPrimaryKey, boolean updateCache)
throws SystemException {
long[] rightPrimaryKeys = getPrimaryKeys(
leftToRightPortalCache, getRightPrimaryKeysSqlQuery, leftPrimaryKey,
updateCache);
if (Arrays.binarySearch(rightPrimaryKeys, rightPrimaryKey) < 0) {
return false;
}
else {
return true;
}
}
protected SqlUpdate addTableMappingSqlUpdate;
protected SqlUpdate deleteLeftPrimaryKeyTableMappingsSqlUpdate;
protected SqlUpdate deleteRightPrimaryKeyTableMappingsSqlUpdate;
protected SqlUpdate deleteTableMappingSqlUpdate;
protected MappingSqlQuery getLeftPrimaryKeysSqlQuery;
protected MappingSqlQuery getRightPrimaryKeysSqlQuery;
protected BasePersistence leftBasePersistence;
protected String leftColumnName;
protected PortalCache leftToRightPortalCache;
protected TableMapper reverseTableMapper;
protected BasePersistence rightBasePersistence;
protected String rightColumnName;
protected PortalCache rightToLeftPortalCache;
}