001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.asset.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.asset.model.AssetVocabulary; 022 023 /** 024 * The persistence interface for the asset vocabulary service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl 032 * @see AssetVocabularyUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface AssetVocabularyPersistence extends BasePersistence<AssetVocabulary> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link AssetVocabularyUtil} to access the asset vocabulary persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the asset vocabularies where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching asset vocabularies 048 */ 049 public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the asset vocabularies where uuid = ?. 053 * 054 * <p> 055 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 056 * </p> 057 * 058 * @param uuid the uuid 059 * @param start the lower bound of the range of asset vocabularies 060 * @param end the upper bound of the range of asset vocabularies (not inclusive) 061 * @return the range of matching asset vocabularies 062 */ 063 public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the asset vocabularies where uuid = ?. 068 * 069 * <p> 070 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 071 * </p> 072 * 073 * @param uuid the uuid 074 * @param start the lower bound of the range of asset vocabularies 075 * @param end the upper bound of the range of asset vocabularies (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching asset vocabularies 078 */ 079 public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 082 083 /** 084 * Returns an ordered range of all the asset vocabularies where uuid = ?. 085 * 086 * <p> 087 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 088 * </p> 089 * 090 * @param uuid the uuid 091 * @param start the lower bound of the range of asset vocabularies 092 * @param end the upper bound of the range of asset vocabularies (not inclusive) 093 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 094 * @param retrieveFromCache whether to retrieve from the finder cache 095 * @return the ordered range of matching asset vocabularies 096 */ 097 public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid, 098 int start, int end, 099 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 100 boolean retrieveFromCache); 101 102 /** 103 * Returns the first asset vocabulary in the ordered set where uuid = ?. 104 * 105 * @param uuid the uuid 106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 107 * @return the first matching asset vocabulary 108 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 109 */ 110 public AssetVocabulary findByUuid_First(java.lang.String uuid, 111 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 112 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 113 114 /** 115 * Returns the first asset vocabulary in the ordered set where uuid = ?. 116 * 117 * @param uuid the uuid 118 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 119 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 120 */ 121 public AssetVocabulary fetchByUuid_First(java.lang.String uuid, 122 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 123 124 /** 125 * Returns the last asset vocabulary in the ordered set where uuid = ?. 126 * 127 * @param uuid the uuid 128 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 129 * @return the last matching asset vocabulary 130 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 131 */ 132 public AssetVocabulary findByUuid_Last(java.lang.String uuid, 133 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 134 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 135 136 /** 137 * Returns the last asset vocabulary in the ordered set where uuid = ?. 138 * 139 * @param uuid the uuid 140 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 141 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 142 */ 143 public AssetVocabulary fetchByUuid_Last(java.lang.String uuid, 144 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 145 146 /** 147 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ?. 148 * 149 * @param vocabularyId the primary key of the current asset vocabulary 150 * @param uuid the uuid 151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 152 * @return the previous, current, and next asset vocabulary 153 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 154 */ 155 public AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId, 156 java.lang.String uuid, 157 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 158 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 159 160 /** 161 * Removes all the asset vocabularies where uuid = ? from the database. 162 * 163 * @param uuid the uuid 164 */ 165 public void removeByUuid(java.lang.String uuid); 166 167 /** 168 * Returns the number of asset vocabularies where uuid = ?. 169 * 170 * @param uuid the uuid 171 * @return the number of matching asset vocabularies 172 */ 173 public int countByUuid(java.lang.String uuid); 174 175 /** 176 * Returns the asset vocabulary where uuid = ? and groupId = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 177 * 178 * @param uuid the uuid 179 * @param groupId the group ID 180 * @return the matching asset vocabulary 181 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 182 */ 183 public AssetVocabulary findByUUID_G(java.lang.String uuid, long groupId) 184 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 185 186 /** 187 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 188 * 189 * @param uuid the uuid 190 * @param groupId the group ID 191 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 192 */ 193 public AssetVocabulary fetchByUUID_G(java.lang.String uuid, long groupId); 194 195 /** 196 * Returns the asset vocabulary where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 197 * 198 * @param uuid the uuid 199 * @param groupId the group ID 200 * @param retrieveFromCache whether to retrieve from the finder cache 201 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 202 */ 203 public AssetVocabulary fetchByUUID_G(java.lang.String uuid, long groupId, 204 boolean retrieveFromCache); 205 206 /** 207 * Removes the asset vocabulary where uuid = ? and groupId = ? from the database. 208 * 209 * @param uuid the uuid 210 * @param groupId the group ID 211 * @return the asset vocabulary that was removed 212 */ 213 public AssetVocabulary removeByUUID_G(java.lang.String uuid, long groupId) 214 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 215 216 /** 217 * Returns the number of asset vocabularies where uuid = ? and groupId = ?. 218 * 219 * @param uuid the uuid 220 * @param groupId the group ID 221 * @return the number of matching asset vocabularies 222 */ 223 public int countByUUID_G(java.lang.String uuid, long groupId); 224 225 /** 226 * Returns all the asset vocabularies where uuid = ? and companyId = ?. 227 * 228 * @param uuid the uuid 229 * @param companyId the company ID 230 * @return the matching asset vocabularies 231 */ 232 public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 233 long companyId); 234 235 /** 236 * Returns a range of all the asset vocabularies where uuid = ? and companyId = ?. 237 * 238 * <p> 239 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 240 * </p> 241 * 242 * @param uuid the uuid 243 * @param companyId the company ID 244 * @param start the lower bound of the range of asset vocabularies 245 * @param end the upper bound of the range of asset vocabularies (not inclusive) 246 * @return the range of matching asset vocabularies 247 */ 248 public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 249 long companyId, int start, int end); 250 251 /** 252 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 253 * 254 * <p> 255 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 256 * </p> 257 * 258 * @param uuid the uuid 259 * @param companyId the company ID 260 * @param start the lower bound of the range of asset vocabularies 261 * @param end the upper bound of the range of asset vocabularies (not inclusive) 262 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 263 * @return the ordered range of matching asset vocabularies 264 */ 265 public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 266 long companyId, int start, int end, 267 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 268 269 /** 270 * Returns an ordered range of all the asset vocabularies where uuid = ? and companyId = ?. 271 * 272 * <p> 273 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 274 * </p> 275 * 276 * @param uuid the uuid 277 * @param companyId the company ID 278 * @param start the lower bound of the range of asset vocabularies 279 * @param end the upper bound of the range of asset vocabularies (not inclusive) 280 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 281 * @param retrieveFromCache whether to retrieve from the finder cache 282 * @return the ordered range of matching asset vocabularies 283 */ 284 public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid, 285 long companyId, int start, int end, 286 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 287 boolean retrieveFromCache); 288 289 /** 290 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 291 * 292 * @param uuid the uuid 293 * @param companyId the company ID 294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 295 * @return the first matching asset vocabulary 296 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 297 */ 298 public AssetVocabulary findByUuid_C_First(java.lang.String uuid, 299 long companyId, 300 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 301 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 302 303 /** 304 * Returns the first asset vocabulary in the ordered set where uuid = ? and companyId = ?. 305 * 306 * @param uuid the uuid 307 * @param companyId the company ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 310 */ 311 public AssetVocabulary fetchByUuid_C_First(java.lang.String uuid, 312 long companyId, 313 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 314 315 /** 316 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 317 * 318 * @param uuid the uuid 319 * @param companyId the company ID 320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 321 * @return the last matching asset vocabulary 322 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 323 */ 324 public AssetVocabulary findByUuid_C_Last(java.lang.String uuid, 325 long companyId, 326 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 327 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 328 329 /** 330 * Returns the last asset vocabulary in the ordered set where uuid = ? and companyId = ?. 331 * 332 * @param uuid the uuid 333 * @param companyId the company ID 334 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 335 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 336 */ 337 public AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid, 338 long companyId, 339 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 340 341 /** 342 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = ? and companyId = ?. 343 * 344 * @param vocabularyId the primary key of the current asset vocabulary 345 * @param uuid the uuid 346 * @param companyId the company ID 347 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 348 * @return the previous, current, and next asset vocabulary 349 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 350 */ 351 public AssetVocabulary[] findByUuid_C_PrevAndNext(long vocabularyId, 352 java.lang.String uuid, long companyId, 353 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 354 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 355 356 /** 357 * Removes all the asset vocabularies where uuid = ? and companyId = ? from the database. 358 * 359 * @param uuid the uuid 360 * @param companyId the company ID 361 */ 362 public void removeByUuid_C(java.lang.String uuid, long companyId); 363 364 /** 365 * Returns the number of asset vocabularies where uuid = ? and companyId = ?. 366 * 367 * @param uuid the uuid 368 * @param companyId the company ID 369 * @return the number of matching asset vocabularies 370 */ 371 public int countByUuid_C(java.lang.String uuid, long companyId); 372 373 /** 374 * Returns all the asset vocabularies where groupId = ?. 375 * 376 * @param groupId the group ID 377 * @return the matching asset vocabularies 378 */ 379 public java.util.List<AssetVocabulary> findByGroupId(long groupId); 380 381 /** 382 * Returns a range of all the asset vocabularies where groupId = ?. 383 * 384 * <p> 385 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 386 * </p> 387 * 388 * @param groupId the group ID 389 * @param start the lower bound of the range of asset vocabularies 390 * @param end the upper bound of the range of asset vocabularies (not inclusive) 391 * @return the range of matching asset vocabularies 392 */ 393 public java.util.List<AssetVocabulary> findByGroupId(long groupId, 394 int start, int end); 395 396 /** 397 * Returns an ordered range of all the asset vocabularies where groupId = ?. 398 * 399 * <p> 400 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 401 * </p> 402 * 403 * @param groupId the group ID 404 * @param start the lower bound of the range of asset vocabularies 405 * @param end the upper bound of the range of asset vocabularies (not inclusive) 406 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 407 * @return the ordered range of matching asset vocabularies 408 */ 409 public java.util.List<AssetVocabulary> findByGroupId(long groupId, 410 int start, int end, 411 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 412 413 /** 414 * Returns an ordered range of all the asset vocabularies where groupId = ?. 415 * 416 * <p> 417 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 418 * </p> 419 * 420 * @param groupId the group ID 421 * @param start the lower bound of the range of asset vocabularies 422 * @param end the upper bound of the range of asset vocabularies (not inclusive) 423 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 424 * @param retrieveFromCache whether to retrieve from the finder cache 425 * @return the ordered range of matching asset vocabularies 426 */ 427 public java.util.List<AssetVocabulary> findByGroupId(long groupId, 428 int start, int end, 429 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 430 boolean retrieveFromCache); 431 432 /** 433 * Returns the first asset vocabulary in the ordered set where groupId = ?. 434 * 435 * @param groupId the group ID 436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 437 * @return the first matching asset vocabulary 438 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 439 */ 440 public AssetVocabulary findByGroupId_First(long groupId, 441 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 442 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 443 444 /** 445 * Returns the first asset vocabulary in the ordered set where groupId = ?. 446 * 447 * @param groupId the group ID 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 450 */ 451 public AssetVocabulary fetchByGroupId_First(long groupId, 452 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 453 454 /** 455 * Returns the last asset vocabulary in the ordered set where groupId = ?. 456 * 457 * @param groupId the group ID 458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 459 * @return the last matching asset vocabulary 460 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 461 */ 462 public AssetVocabulary findByGroupId_Last(long groupId, 463 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 464 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 465 466 /** 467 * Returns the last asset vocabulary in the ordered set where groupId = ?. 468 * 469 * @param groupId the group ID 470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 471 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 472 */ 473 public AssetVocabulary fetchByGroupId_Last(long groupId, 474 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 475 476 /** 477 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ?. 478 * 479 * @param vocabularyId the primary key of the current asset vocabulary 480 * @param groupId the group ID 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the previous, current, and next asset vocabulary 483 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 484 */ 485 public AssetVocabulary[] findByGroupId_PrevAndNext(long vocabularyId, 486 long groupId, 487 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 488 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 489 490 /** 491 * Returns all the asset vocabularies that the user has permission to view where groupId = ?. 492 * 493 * @param groupId the group ID 494 * @return the matching asset vocabularies that the user has permission to view 495 */ 496 public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId); 497 498 /** 499 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ?. 500 * 501 * <p> 502 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 503 * </p> 504 * 505 * @param groupId the group ID 506 * @param start the lower bound of the range of asset vocabularies 507 * @param end the upper bound of the range of asset vocabularies (not inclusive) 508 * @return the range of matching asset vocabularies that the user has permission to view 509 */ 510 public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId, 511 int start, int end); 512 513 /** 514 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ?. 515 * 516 * <p> 517 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 518 * </p> 519 * 520 * @param groupId the group ID 521 * @param start the lower bound of the range of asset vocabularies 522 * @param end the upper bound of the range of asset vocabularies (not inclusive) 523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 524 * @return the ordered range of matching asset vocabularies that the user has permission to view 525 */ 526 public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId, 527 int start, int end, 528 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 529 530 /** 531 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = ?. 532 * 533 * @param vocabularyId the primary key of the current asset vocabulary 534 * @param groupId the group ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the previous, current, and next asset vocabulary 537 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 538 */ 539 public AssetVocabulary[] filterFindByGroupId_PrevAndNext( 540 long vocabularyId, long groupId, 541 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 542 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 543 544 /** 545 * Returns all the asset vocabularies that the user has permission to view where groupId = any ?. 546 * 547 * @param groupIds the group IDs 548 * @return the matching asset vocabularies that the user has permission to view 549 */ 550 public java.util.List<AssetVocabulary> filterFindByGroupId(long[] groupIds); 551 552 /** 553 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any ?. 554 * 555 * <p> 556 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 557 * </p> 558 * 559 * @param groupIds the group IDs 560 * @param start the lower bound of the range of asset vocabularies 561 * @param end the upper bound of the range of asset vocabularies (not inclusive) 562 * @return the range of matching asset vocabularies that the user has permission to view 563 */ 564 public java.util.List<AssetVocabulary> filterFindByGroupId( 565 long[] groupIds, int start, int end); 566 567 /** 568 * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any ?. 569 * 570 * <p> 571 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 572 * </p> 573 * 574 * @param groupIds the group IDs 575 * @param start the lower bound of the range of asset vocabularies 576 * @param end the upper bound of the range of asset vocabularies (not inclusive) 577 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 578 * @return the ordered range of matching asset vocabularies that the user has permission to view 579 */ 580 public java.util.List<AssetVocabulary> filterFindByGroupId( 581 long[] groupIds, int start, int end, 582 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 583 584 /** 585 * Returns all the asset vocabularies where groupId = any ?. 586 * 587 * <p> 588 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 589 * </p> 590 * 591 * @param groupIds the group IDs 592 * @return the matching asset vocabularies 593 */ 594 public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds); 595 596 /** 597 * Returns a range of all the asset vocabularies where groupId = any ?. 598 * 599 * <p> 600 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 601 * </p> 602 * 603 * @param groupIds the group IDs 604 * @param start the lower bound of the range of asset vocabularies 605 * @param end the upper bound of the range of asset vocabularies (not inclusive) 606 * @return the range of matching asset vocabularies 607 */ 608 public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds, 609 int start, int end); 610 611 /** 612 * Returns an ordered range of all the asset vocabularies where groupId = any ?. 613 * 614 * <p> 615 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 616 * </p> 617 * 618 * @param groupIds the group IDs 619 * @param start the lower bound of the range of asset vocabularies 620 * @param end the upper bound of the range of asset vocabularies (not inclusive) 621 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 622 * @return the ordered range of matching asset vocabularies 623 */ 624 public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds, 625 int start, int end, 626 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 627 628 /** 629 * Returns an ordered range of all the asset vocabularies where groupId = ?, optionally using the finder cache. 630 * 631 * <p> 632 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 633 * </p> 634 * 635 * @param groupId the group ID 636 * @param start the lower bound of the range of asset vocabularies 637 * @param end the upper bound of the range of asset vocabularies (not inclusive) 638 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 639 * @param retrieveFromCache whether to retrieve from the finder cache 640 * @return the ordered range of matching asset vocabularies 641 */ 642 public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds, 643 int start, int end, 644 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 645 boolean retrieveFromCache); 646 647 /** 648 * Removes all the asset vocabularies where groupId = ? from the database. 649 * 650 * @param groupId the group ID 651 */ 652 public void removeByGroupId(long groupId); 653 654 /** 655 * Returns the number of asset vocabularies where groupId = ?. 656 * 657 * @param groupId the group ID 658 * @return the number of matching asset vocabularies 659 */ 660 public int countByGroupId(long groupId); 661 662 /** 663 * Returns the number of asset vocabularies where groupId = any ?. 664 * 665 * @param groupIds the group IDs 666 * @return the number of matching asset vocabularies 667 */ 668 public int countByGroupId(long[] groupIds); 669 670 /** 671 * Returns the number of asset vocabularies that the user has permission to view where groupId = ?. 672 * 673 * @param groupId the group ID 674 * @return the number of matching asset vocabularies that the user has permission to view 675 */ 676 public int filterCountByGroupId(long groupId); 677 678 /** 679 * Returns the number of asset vocabularies that the user has permission to view where groupId = any ?. 680 * 681 * @param groupIds the group IDs 682 * @return the number of matching asset vocabularies that the user has permission to view 683 */ 684 public int filterCountByGroupId(long[] groupIds); 685 686 /** 687 * Returns all the asset vocabularies where companyId = ?. 688 * 689 * @param companyId the company ID 690 * @return the matching asset vocabularies 691 */ 692 public java.util.List<AssetVocabulary> findByCompanyId(long companyId); 693 694 /** 695 * Returns a range of all the asset vocabularies where companyId = ?. 696 * 697 * <p> 698 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 699 * </p> 700 * 701 * @param companyId the company ID 702 * @param start the lower bound of the range of asset vocabularies 703 * @param end the upper bound of the range of asset vocabularies (not inclusive) 704 * @return the range of matching asset vocabularies 705 */ 706 public java.util.List<AssetVocabulary> findByCompanyId(long companyId, 707 int start, int end); 708 709 /** 710 * Returns an ordered range of all the asset vocabularies where companyId = ?. 711 * 712 * <p> 713 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 714 * </p> 715 * 716 * @param companyId the company ID 717 * @param start the lower bound of the range of asset vocabularies 718 * @param end the upper bound of the range of asset vocabularies (not inclusive) 719 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 720 * @return the ordered range of matching asset vocabularies 721 */ 722 public java.util.List<AssetVocabulary> findByCompanyId(long companyId, 723 int start, int end, 724 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 725 726 /** 727 * Returns an ordered range of all the asset vocabularies where companyId = ?. 728 * 729 * <p> 730 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 731 * </p> 732 * 733 * @param companyId the company ID 734 * @param start the lower bound of the range of asset vocabularies 735 * @param end the upper bound of the range of asset vocabularies (not inclusive) 736 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 737 * @param retrieveFromCache whether to retrieve from the finder cache 738 * @return the ordered range of matching asset vocabularies 739 */ 740 public java.util.List<AssetVocabulary> findByCompanyId(long companyId, 741 int start, int end, 742 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 743 boolean retrieveFromCache); 744 745 /** 746 * Returns the first asset vocabulary in the ordered set where companyId = ?. 747 * 748 * @param companyId the company ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching asset vocabulary 751 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 752 */ 753 public AssetVocabulary findByCompanyId_First(long companyId, 754 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 755 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 756 757 /** 758 * Returns the first asset vocabulary in the ordered set where companyId = ?. 759 * 760 * @param companyId the company ID 761 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 762 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 763 */ 764 public AssetVocabulary fetchByCompanyId_First(long companyId, 765 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 766 767 /** 768 * Returns the last asset vocabulary in the ordered set where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 772 * @return the last matching asset vocabulary 773 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 774 */ 775 public AssetVocabulary findByCompanyId_Last(long companyId, 776 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 777 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 778 779 /** 780 * Returns the last asset vocabulary in the ordered set where companyId = ?. 781 * 782 * @param companyId the company ID 783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 784 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 785 */ 786 public AssetVocabulary fetchByCompanyId_Last(long companyId, 787 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 788 789 /** 790 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = ?. 791 * 792 * @param vocabularyId the primary key of the current asset vocabulary 793 * @param companyId the company ID 794 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 795 * @return the previous, current, and next asset vocabulary 796 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 797 */ 798 public AssetVocabulary[] findByCompanyId_PrevAndNext(long vocabularyId, 799 long companyId, 800 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 801 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 802 803 /** 804 * Removes all the asset vocabularies where companyId = ? from the database. 805 * 806 * @param companyId the company ID 807 */ 808 public void removeByCompanyId(long companyId); 809 810 /** 811 * Returns the number of asset vocabularies where companyId = ?. 812 * 813 * @param companyId the company ID 814 * @return the number of matching asset vocabularies 815 */ 816 public int countByCompanyId(long companyId); 817 818 /** 819 * Returns the asset vocabulary where groupId = ? and name = ? or throws a {@link NoSuchVocabularyException} if it could not be found. 820 * 821 * @param groupId the group ID 822 * @param name the name 823 * @return the matching asset vocabulary 824 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 825 */ 826 public AssetVocabulary findByG_N(long groupId, java.lang.String name) 827 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 828 829 /** 830 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 831 * 832 * @param groupId the group ID 833 * @param name the name 834 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 835 */ 836 public AssetVocabulary fetchByG_N(long groupId, java.lang.String name); 837 838 /** 839 * Returns the asset vocabulary where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 840 * 841 * @param groupId the group ID 842 * @param name the name 843 * @param retrieveFromCache whether to retrieve from the finder cache 844 * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 845 */ 846 public AssetVocabulary fetchByG_N(long groupId, java.lang.String name, 847 boolean retrieveFromCache); 848 849 /** 850 * Removes the asset vocabulary where groupId = ? and name = ? from the database. 851 * 852 * @param groupId the group ID 853 * @param name the name 854 * @return the asset vocabulary that was removed 855 */ 856 public AssetVocabulary removeByG_N(long groupId, java.lang.String name) 857 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 858 859 /** 860 * Returns the number of asset vocabularies where groupId = ? and name = ?. 861 * 862 * @param groupId the group ID 863 * @param name the name 864 * @return the number of matching asset vocabularies 865 */ 866 public int countByG_N(long groupId, java.lang.String name); 867 868 /** 869 * Returns all the asset vocabularies where groupId = ? and name LIKE ?. 870 * 871 * @param groupId the group ID 872 * @param name the name 873 * @return the matching asset vocabularies 874 */ 875 public java.util.List<AssetVocabulary> findByG_LikeN(long groupId, 876 java.lang.String name); 877 878 /** 879 * Returns a range of all the asset vocabularies where groupId = ? and name LIKE ?. 880 * 881 * <p> 882 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 883 * </p> 884 * 885 * @param groupId the group ID 886 * @param name the name 887 * @param start the lower bound of the range of asset vocabularies 888 * @param end the upper bound of the range of asset vocabularies (not inclusive) 889 * @return the range of matching asset vocabularies 890 */ 891 public java.util.List<AssetVocabulary> findByG_LikeN(long groupId, 892 java.lang.String name, int start, int end); 893 894 /** 895 * Returns an ordered range of all the asset vocabularies where groupId = ? and name LIKE ?. 896 * 897 * <p> 898 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 899 * </p> 900 * 901 * @param groupId the group ID 902 * @param name the name 903 * @param start the lower bound of the range of asset vocabularies 904 * @param end the upper bound of the range of asset vocabularies (not inclusive) 905 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 906 * @return the ordered range of matching asset vocabularies 907 */ 908 public java.util.List<AssetVocabulary> findByG_LikeN(long groupId, 909 java.lang.String name, int start, int end, 910 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 911 912 /** 913 * Returns an ordered range of all the asset vocabularies where groupId = ? and name LIKE ?. 914 * 915 * <p> 916 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 917 * </p> 918 * 919 * @param groupId the group ID 920 * @param name the name 921 * @param start the lower bound of the range of asset vocabularies 922 * @param end the upper bound of the range of asset vocabularies (not inclusive) 923 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 924 * @param retrieveFromCache whether to retrieve from the finder cache 925 * @return the ordered range of matching asset vocabularies 926 */ 927 public java.util.List<AssetVocabulary> findByG_LikeN(long groupId, 928 java.lang.String name, int start, int end, 929 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 930 boolean retrieveFromCache); 931 932 /** 933 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 934 * 935 * @param groupId the group ID 936 * @param name the name 937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 938 * @return the first matching asset vocabulary 939 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 940 */ 941 public AssetVocabulary findByG_LikeN_First(long groupId, 942 java.lang.String name, 943 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 944 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 945 946 /** 947 * Returns the first asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 948 * 949 * @param groupId the group ID 950 * @param name the name 951 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 952 * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 953 */ 954 public AssetVocabulary fetchByG_LikeN_First(long groupId, 955 java.lang.String name, 956 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 957 958 /** 959 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 960 * 961 * @param groupId the group ID 962 * @param name the name 963 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 964 * @return the last matching asset vocabulary 965 * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found 966 */ 967 public AssetVocabulary findByG_LikeN_Last(long groupId, 968 java.lang.String name, 969 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 970 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 971 972 /** 973 * Returns the last asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 974 * 975 * @param groupId the group ID 976 * @param name the name 977 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 978 * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found 979 */ 980 public AssetVocabulary fetchByG_LikeN_Last(long groupId, 981 java.lang.String name, 982 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 983 984 /** 985 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = ? and name LIKE ?. 986 * 987 * @param vocabularyId the primary key of the current asset vocabulary 988 * @param groupId the group ID 989 * @param name the name 990 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 991 * @return the previous, current, and next asset vocabulary 992 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 993 */ 994 public AssetVocabulary[] findByG_LikeN_PrevAndNext(long vocabularyId, 995 long groupId, java.lang.String name, 996 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 997 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 998 999 /** 1000 * Returns all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1001 * 1002 * @param groupId the group ID 1003 * @param name the name 1004 * @return the matching asset vocabularies that the user has permission to view 1005 */ 1006 public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1007 java.lang.String name); 1008 1009 /** 1010 * Returns a range of all the asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1011 * 1012 * <p> 1013 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1014 * </p> 1015 * 1016 * @param groupId the group ID 1017 * @param name the name 1018 * @param start the lower bound of the range of asset vocabularies 1019 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1020 * @return the range of matching asset vocabularies that the user has permission to view 1021 */ 1022 public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1023 java.lang.String name, int start, int end); 1024 1025 /** 1026 * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = ? and name LIKE ?. 1027 * 1028 * <p> 1029 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1030 * </p> 1031 * 1032 * @param groupId the group ID 1033 * @param name the name 1034 * @param start the lower bound of the range of asset vocabularies 1035 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1036 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1037 * @return the ordered range of matching asset vocabularies that the user has permission to view 1038 */ 1039 public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId, 1040 java.lang.String name, int start, int end, 1041 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 1042 1043 /** 1044 * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1045 * 1046 * @param vocabularyId the primary key of the current asset vocabulary 1047 * @param groupId the group ID 1048 * @param name the name 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the previous, current, and next asset vocabulary 1051 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1052 */ 1053 public AssetVocabulary[] filterFindByG_LikeN_PrevAndNext( 1054 long vocabularyId, long groupId, java.lang.String name, 1055 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator) 1056 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 1057 1058 /** 1059 * Removes all the asset vocabularies where groupId = ? and name LIKE ? from the database. 1060 * 1061 * @param groupId the group ID 1062 * @param name the name 1063 */ 1064 public void removeByG_LikeN(long groupId, java.lang.String name); 1065 1066 /** 1067 * Returns the number of asset vocabularies where groupId = ? and name LIKE ?. 1068 * 1069 * @param groupId the group ID 1070 * @param name the name 1071 * @return the number of matching asset vocabularies 1072 */ 1073 public int countByG_LikeN(long groupId, java.lang.String name); 1074 1075 /** 1076 * Returns the number of asset vocabularies that the user has permission to view where groupId = ? and name LIKE ?. 1077 * 1078 * @param groupId the group ID 1079 * @param name the name 1080 * @return the number of matching asset vocabularies that the user has permission to view 1081 */ 1082 public int filterCountByG_LikeN(long groupId, java.lang.String name); 1083 1084 /** 1085 * Caches the asset vocabulary in the entity cache if it is enabled. 1086 * 1087 * @param assetVocabulary the asset vocabulary 1088 */ 1089 public void cacheResult(AssetVocabulary assetVocabulary); 1090 1091 /** 1092 * Caches the asset vocabularies in the entity cache if it is enabled. 1093 * 1094 * @param assetVocabularies the asset vocabularies 1095 */ 1096 public void cacheResult(java.util.List<AssetVocabulary> assetVocabularies); 1097 1098 /** 1099 * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database. 1100 * 1101 * @param vocabularyId the primary key for the new asset vocabulary 1102 * @return the new asset vocabulary 1103 */ 1104 public AssetVocabulary create(long vocabularyId); 1105 1106 /** 1107 * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners. 1108 * 1109 * @param vocabularyId the primary key of the asset vocabulary 1110 * @return the asset vocabulary that was removed 1111 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1112 */ 1113 public AssetVocabulary remove(long vocabularyId) 1114 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 1115 1116 public AssetVocabulary updateImpl(AssetVocabulary assetVocabulary); 1117 1118 /** 1119 * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found. 1120 * 1121 * @param vocabularyId the primary key of the asset vocabulary 1122 * @return the asset vocabulary 1123 * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found 1124 */ 1125 public AssetVocabulary findByPrimaryKey(long vocabularyId) 1126 throws com.liferay.portlet.asset.exception.NoSuchVocabularyException; 1127 1128 /** 1129 * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found. 1130 * 1131 * @param vocabularyId the primary key of the asset vocabulary 1132 * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found 1133 */ 1134 public AssetVocabulary fetchByPrimaryKey(long vocabularyId); 1135 1136 @Override 1137 public java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys( 1138 java.util.Set<java.io.Serializable> primaryKeys); 1139 1140 /** 1141 * Returns all the asset vocabularies. 1142 * 1143 * @return the asset vocabularies 1144 */ 1145 public java.util.List<AssetVocabulary> findAll(); 1146 1147 /** 1148 * Returns a range of all the asset vocabularies. 1149 * 1150 * <p> 1151 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1152 * </p> 1153 * 1154 * @param start the lower bound of the range of asset vocabularies 1155 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1156 * @return the range of asset vocabularies 1157 */ 1158 public java.util.List<AssetVocabulary> findAll(int start, int end); 1159 1160 /** 1161 * Returns an ordered range of all the asset vocabularies. 1162 * 1163 * <p> 1164 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1165 * </p> 1166 * 1167 * @param start the lower bound of the range of asset vocabularies 1168 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1170 * @return the ordered range of asset vocabularies 1171 */ 1172 public java.util.List<AssetVocabulary> findAll(int start, int end, 1173 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator); 1174 1175 /** 1176 * Returns an ordered range of all the asset vocabularies. 1177 * 1178 * <p> 1179 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1180 * </p> 1181 * 1182 * @param start the lower bound of the range of asset vocabularies 1183 * @param end the upper bound of the range of asset vocabularies (not inclusive) 1184 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1185 * @param retrieveFromCache whether to retrieve from the finder cache 1186 * @return the ordered range of asset vocabularies 1187 */ 1188 public java.util.List<AssetVocabulary> findAll(int start, int end, 1189 com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator, 1190 boolean retrieveFromCache); 1191 1192 /** 1193 * Removes all the asset vocabularies from the database. 1194 */ 1195 public void removeAll(); 1196 1197 /** 1198 * Returns the number of asset vocabularies. 1199 * 1200 * @return the number of asset vocabularies 1201 */ 1202 public int countAll(); 1203 1204 @Override 1205 public java.util.Set<java.lang.String> getBadColumnNames(); 1206 }