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