Returns for given parameter <i>_uuid</i> the instance of class
{@link SQLTable}.

@param _uuid UUID the tanel is wanted for
@return instance of class {@link Type}
@throws CacheReloadException on error
558280
public static SQLTable get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, SQLTable> cache = InfinispanCache.get().<UUID, SQLTable>getCache(SQLTable.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            SQLTable.getSQLTableFromDB(SQLTable.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
239979
public function byUuid(AggregateUuid $uuid, $returnType = self::RETURN_AS_ARRAY)
    {
        $uuid = (string) $uuid;
        $query = 'SELECT
                  `uuid`,
                  `version`,
                  `payload`,
                  `type`,
                  `body`,
                  `occurred_on`
                FROM `'.PdoDriver::EVENTSTORE_TABLE_NAME.'` 
                WHERE `uuid` = :uuid
                ORDER BY `occurred_on` ASC';
        $stmt = $this->pdo->prepare($query);
        $stmt->bindParam(':uuid', $uuid);
        $stmt->execute();

        $row = $stmt->fetchAll(\PDO::FETCH_ASSOC);

        if (!empty($row)) {
            return $this->buildEventAggregate($row, $returnType);
        }

        return null;
    }
1360530
public CachedInstanceQuery getCachedQuery4Request()
    {
        if (this.query == null) {
            try {
                this.query = CachedInstanceQuery.get4Request(this.typeUUID)
                                .setIncludeChildTypes(isIncludeChildTypes())
                                .setCompanyDependent(isCompanyDependent());
                prepareQuery();
            } catch (final EFapsException e) {
                QueryBuilder.LOG.error("Could not open InstanceQuery for uuid: {}", this.typeUUID);
            }
        }
        return (CachedInstanceQuery) this.query;
    }
1261795
public static Type get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Type> cache = InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Type.getTypeFromDB(Type.SQL_UUID, _uuid.toString());
        }
        Type ret = cache.get(_uuid);
        if (ret != null && ret.isDirty()) {
            Type.LOG.debug("Recaching dirty Type for uuid: {}", ret);
            Type.cacheType(ret);
            ret = cache.get(_uuid);
        }
        return ret;
    }
721414
public static Dimension get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Dimension> cache = InfinispanCache.get().<String, Dimension>getCache(Dimension.NAMECACHE);
        if (!cache.containsKey(_name)) {
            Dimension.getDimensionFromDB(Dimension.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
234083
public static Type get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Type> cache = InfinispanCache.get().<Long, Type>getCache(Type.IDCACHE);
        if (!cache.containsKey(_id)) {
            Type.getTypeFromDB(Type.SQL_ID, _id);
        }
        Type ret = cache.get(_id);
        if (ret != null && ret.isDirty()) {
            Type.LOG.debug("Recaching dirty Type for id: {}", ret);
            Type.cacheType(ret);
            ret = cache.get(_id);
        }
        return ret;
    }
145378
public org.efaps.admin.ui.Table getType()
    {
        org.efaps.admin.ui.Table ret = null;
        try {
            ret =  org.efaps.admin.ui.Table.get(this.uuid);
        } catch (final CacheReloadException e) {
            CITable.LOG.error("Error on retrieving Type for CIType with uuid: {}", this.uuid);
        }
        return ret;
    }
1164105
public static Person get(final UUID _uuid)
        throws EFapsException
    {
        final Cache<UUID, Person> cache = InfinispanCache.get().<UUID, Person>getCache(Person.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Person.getPersonFromDB(Person.SQL_UUID, _uuid.toString());
        }
        return cache.get(_uuid);
    }
1083354
@Id
	@Column(length = 36, nullable = true)
	@GeneratedValue(generator = "uuid")
	@GenericGenerator(name = "uuid", strategy = "uuid2")
	public String getId() {
		return id;
	}
1326633
function(cacheNum) {
      if (cacheNum === undefined) {
        cacheNum = 1;
      }
      if (!uuidCache.length) {
        ajax({url: this.urlPrefix + "/_uuids", data: {count: cacheNum}, async:
              false}, {
            success: function(resp) {
              uuidCache = resp.uuids;
            }
          },
          "Failed to retrieve UUID batch."
        );
      }
      return uuidCache.shift();
    }
585420
private synchronized Identity getNodeFromCache(final String uuid) {

		if (nodeUuidMap == null) {

			nodeUuidMap = new FixedSizeCache<>(Settings.UuidCacheSize.getValue());
		}

		return nodeUuidMap.get(uuid);
	}
93583
def uuid(cls):
        """"""
        if hasattr(cls, '__uuid_primary_key__') and cls.__uuid_primary_key__:
            return synonym('id')
        else:
            return immutable(Column(UUIDType(binary=False), default=uuid_.uuid4, unique=True, nullable=False))
1252941
private <T> T getInstance(DatastoreType datastoreType, TransactionalCache.Mode cacheMode) {
        DatastoreId id = getDatastoreId(datastoreType);
        Object instance = cache.get(id, cacheMode);
        if (instance == null) {
            DynamicType<?> types = getTypes(datastoreType);
            instance = newInstance(id, datastoreType, types, cacheMode);
            if (TransactionalCache.Mode.READ.equals(cacheMode)) {
                instanceListenerService.postLoad(instance);
            }
        }
        return (T) instance;
    }
1359289
public static AccessSet get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, AccessSet> cache = InfinispanCache.get().<Long, AccessSet>getCache(AccessSet.IDCACHE);
        if (!cache.containsKey(_id)) {
            AccessSet.getAccessSetFromDB(AccessSet.SQL_ID, _id);
        }
        return cache.get(_id);
    }
278999
public static Company get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Company> cache = InfinispanCache.get().<UUID, Company>getCache(Company.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Company.getCompanyFromDB(Company.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
1274574
public static Group get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Group> cache = InfinispanCache.get().<String, Group>getCache(Group.IDCACHE);
        if (!cache.containsKey(_name) && !Group.getGroupFromDB(Group.SQL_NAME, _name)) {
            cache.put(_name, Group.NULL, 100, TimeUnit.SECONDS);
        }
        final Group ret = cache.get(_name);
        return ret.equals(Group.NULL) ? null : ret;
    }
837084
public static Group get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Group> cache = InfinispanCache.get().<Long, Group>getCache(Group.IDCACHE);
        if (!cache.containsKey(_id) && !Group.getGroupFromDB(Group.SQL_ID, _id)) {
            cache.put(_id, Group.NULL, 100, TimeUnit.SECONDS);
        }
        final Group ret = cache.get(_id);
        return ret.equals(Group.NULL) ? null : ret;
    }