<ol>
<li>First extract the column value from the given GettableData (Row, UDTValue, ...)</li>
<li>Then call the setter on the given entity to set the value</li>
</ol>
@param gettableData
@param entity
325116
public void decodeField(GettableData gettableData, ENTITY entity) {
        final VALUEFROM valuefrom = decodeFromGettable(gettableData);
        fieldInfo.setter.set(entity, valuefrom);
    }
1282297
public VALUEFROM decodeFromGettable(GettableData gettableData) {
        if (gettableData.isNull(NamingHelper.maybeQuote(getColumnForSelect())) && !isOptional()) return null;
        return decodeFromGettableInternal(gettableData);
    }
825758
@Override
	public <T> Entity parseBean(T bean, boolean isToUnderlineCase, boolean ignoreNullValue) {
		if (StrUtil.isBlank(this.tableName)) {
			String simpleName = bean.getClass().getSimpleName();
			this.setTableName(isToUnderlineCase ? StrUtil.toUnderlineCase(simpleName) : StrUtil.lowerFirst(simpleName));
		}
		return (Entity) super.parseBean(bean, isToUnderlineCase, ignoreNullValue);
	}
1168636
public void populate(Entity entity) {
    // auto date
    generateAutoDateOrDateTime(singletonList(entity), entity.getEntityType().getAttributes());

    // auto id
    Attribute idAttr = entity.getEntityType().getIdAttribute();
    if (idAttr != null
        && idAttr.isAuto()
        && entity.getIdValue() == null
        && (idAttr.getDataType() == STRING)) {
      entity.set(idAttr.getName(), idGenerator.generateId());
    }
  }
1130746
private List onRead(EntityMetadata m, List<Map<String, Object>> columnsToOutput, Table hTable,
            List<HBaseDataWrapper> results) throws IOException
    {
        Class clazz = m.getEntityClazz();
        List outputResults = new ArrayList();
        try
        {
            if (results != null)
            {
                return columnsToOutput != null && !columnsToOutput.isEmpty() ? returnSpecificFieldList(m,
                        columnsToOutput, results, outputResults) : returnEntityObjectList(m, results, outputResults);
            }
        }
        catch (Exception e)
        {
            logger.error("Error while creating an instance of {}, Caused by: .", clazz, e);
            throw new PersistenceException(e);
        }
        finally
        {
            if (hTable != null)
            {
                closeHTable(hTable);
            }
        }
        return outputResults;
    }
964828
@Override
	public Object getValueAt(final int row, final int column)
	{

		ConfigItem item = this.list.get(row);

		switch (column) {
		case 0:
			return item.getType();
		case 1:
			return item.getKey();
		case 2:
			return item.getMessage();
		}
		return null;
	}
697168
private void populateSecondaryTableData(Object rowId, Object entity, MetamodelImpl metaModel,
        EntityMetadata metadata) {
        AbstractManagedType managedType = (AbstractManagedType) metaModel.entity(metadata.getEntityClazz());
        List<String> secondaryTables =
            ((DefaultEntityAnnotationProcessor) managedType.getEntityAnnotation()).getSecondaryTablesName();

        for (String tableName : secondaryTables) {
            StringBuilder builder = createSelectQuery(rowId, metadata, tableName);
            ResultSet rSet = this.execute(builder.toString(), null);

            Iterator<Row> rowIter = rSet.iterator();

            Row row = rowIter.next();
            ColumnDefinitions columnDefs = row.getColumnDefinitions();
            Iterator<Definition> columnDefIter = columnDefs.iterator();

            entity = iteratorColumns(metadata, metaModel, metaModel.entity(metadata.getEntityClazz()),
                new HashMap<String, Object>(), entity, row, columnDefIter);
        }
    }
1254726
private void generateColumnsArray(Finder<SQLProperty> entity) {
		// generate columns array
		Builder sp = FieldSpec.builder(ArrayTypeName.of(String.class), "COLUMNS", Modifier.STATIC, Modifier.PRIVATE,
				Modifier.FINAL);
		String s = "";
		StringBuilder buffer = new StringBuilder();
		for (SQLProperty property : entity.getCollection()) {
			buffer.append(s + "COLUMN_" + columnNameToUpperCaseConverter.convert(property.getName()));
			s = ", ";
		}
		classBuilder.addField(sp.addJavadoc("Columns array\n").initializer("{" + buffer.toString() + "}").build());
		classBuilder.addMethod(MethodSpec.methodBuilder("columns").addModifiers(Modifier.PUBLIC)
				.addJavadoc("Columns array\n").addAnnotation(Override.class).returns(ArrayTypeName.of(String.class))
				.addStatement("return COLUMNS").build());

		classBuilder.addMethod(MethodSpec.methodBuilder("name").addModifiers(Modifier.PUBLIC).addJavadoc("table name\n")
				.addAnnotation(Override.class).returns(TypeName.get(String.class)).addStatement("return TABLE_NAME")
				.build());
	}
652482
public void readData(FieldTable table) throws DBException
    {
        if (this.getLookupKey() instanceof String)
        {
            FieldList record = table.getRecord();
            String strTableName = (String)this.getLookupKey();
            String strDBName = null;
            if (strTableName != null)
            {
                if (strTableName.lastIndexOf('/') != -1)
                {
                    strDBName = strTableName.substring(0, strTableName.lastIndexOf('/'));
                    if (strDBName.lastIndexOf('/') != -1)
                        strDBName = strDBName.substring(strDBName.lastIndexOf('/') + 1);
                    strTableName = strTableName.substring(strTableName.lastIndexOf('/') + 1);
                    if (strTableName.indexOf('.') != -1)
                        strTableName = strTableName.substring(0, strTableName.indexOf('.'));
                }
            }

            String strThickRecordClass = record.getClass().getName();
            
            RecordOwner recordOwner = ((Record)record).getRecordOwner();
            BaseDatabase database = (BaseDatabase)recordOwner.getDatabase(record.getDatabaseName(), record.getDatabaseType(), null);
            Record recSource = Record.makeRecordFromClassName(strThickRecordClass, recordOwner, false, true);
            if (recSource == null)
                return;
            if (strTableName != null)
                if (strTableName.length() > 0)
                    if ((!strTableName.equalsIgnoreCase(recSource.getTableNames(false))))
                        if ((recSource.getDatabaseType() & DBConstants.MAPPED) != 0)
                            recSource.setTableNames(strTableName);
            recSource.setTable(database.makeTable(recSource));
            recSource.init(recordOwner);

            recSource.populateThinTable(record, true);
            
            recSource.free();
        }
    }
457404
public void setData(final List data) {
		// Bean properties to render
		String[] properties = new String[]{"colour", "shape", "animal"};

		simpleTable.setDataModel(new SimpleBeanListTableDataModel(properties, data));
	}
227226
private void processTableData() throws IOException
   {
      DirectoryEntry dir = (DirectoryEntry) m_viewDir.getEntry("CTable");

      VarMeta varMeta = new VarMeta12(new DocumentInputStream(((DocumentEntry) dir.getEntry("VarMeta"))));
      Var2Data varData = new Var2Data(varMeta, new DocumentInputStream(((DocumentEntry) dir.getEntry("Var2Data"))));
      FixedData fixedData = new FixedData(230, new DocumentInputStream(((DocumentEntry) dir.getEntry("FixedData"))));
      //System.out.println(varMeta);
      //System.out.println(varData);
      //System.out.println(fixedData);

      TableContainer container = m_file.getTables();
      TableFactory14 factory = new TableFactory14(TABLE_COLUMN_DATA_STANDARD, TABLE_COLUMN_DATA_ENTERPRISE, TABLE_COLUMN_DATA_BASELINE);
      int items = fixedData.getItemCount();
      for (int loop = 0; loop < items; loop++)
      {
         byte[] data = fixedData.getByteArrayValue(loop);
         Table table = factory.createTable(m_file, data, varMeta, varData);
         container.add(table);
         //System.out.println(table);
      }
   }
762904
@Override
    public String getTableRowColumnData(int rowNumber, int columnNumber) throws WidgetException {
        try {
            String[] data = getTableRowDataArray(rowNumber);
            return data[columnNumber - 1];
        } catch (Exception e) {
            throw new WidgetException("Error while getting table row column data at row="
                    + rowNumber + " column=" + columnNumber, generateXPathLocator(), e);
        }
    }
540498
function setTableSelection(table, rowData) {
      if (table.isPanel) {
        table = table.getView();
      }
      var model = this.findRecord(table.getStore(), rowData);

      table.setSelection(model);
    }
1064330
private Object setUdtValue(Object entity, Object thriftColumnValue, MetamodelImpl metaModel, Attribute attribute)
    {
        List<FieldIdentifier> fieldNames = new ArrayList<FieldIdentifier>();
        List<AbstractType<?>> fieldTypes = new ArrayList<AbstractType<?>>();

        String val = null;

        // get from cqlMetadata, details of types and names (for maintaining
        // order)
        Map<ByteBuffer, String> schemaTypes = this.clientBase.getCqlMetadata().getValue_types();
        for (Map.Entry<ByteBuffer, String> schemaType : schemaTypes.entrySet())
        {
            UTF8Serializer utf8Serializer = UTF8Serializer.instance;
            String key = utf8Serializer.deserialize((schemaType.getKey()));
            if (key.equals(((AbstractAttribute) attribute).getJavaMember().getName()))
            {
                val = schemaType.getValue();
                break;
            }
        }

        UserType userType = null;

        try
        {
            userType = UserType.getInstance(new TypeParser(val.substring(val.indexOf("UserType(") + 8, val.length())));
        }
        catch (ConfigurationException | SyntaxException e)
        {
            log.error(e.getMessage());
            throw new KunderaException("Error while getting instance of UserType " + e);
        }

        fieldNames = userType.fieldNames();
        fieldTypes = userType.allTypes();

        Field field = (Field) ((AbstractAttribute) attribute).getJavaMember();
        Class embeddedClass = ((AbstractAttribute) attribute).getBindableJavaType();

        Object embeddedObject = KunderaCoreUtils.createNewInstance(embeddedClass);

        Object finalValue = populateEmbeddedRecursive((ByteBuffer.wrap((byte[]) thriftColumnValue)), fieldTypes,
                fieldNames, embeddedObject, metaModel);

        PropertyAccessorHelper.set(entity, field, finalValue);

        return entity;
    }
562974
@Override
    public List readData(final String tableName, Class clazz, EntityMetadata m, final Object rowKey,
            List<String> relationNames, FilterList f, String... columns) throws IOException
    {

        List output = null;

        Object entity = null;

        HTableInterface hTable = null;

        hTable = gethTable(tableName);

        if (getFilter(m.getTableName()) != null)
        {
            if (f == null)
            {
                f = new FilterList();
            }
            f.addFilter(getFilter(m.getTableName()));
        }

        // Load raw data from HBase
        MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
                m.getPersistenceUnit());

        AbstractManagedType managedType = (AbstractManagedType) metaModel.entity(m.getEntityClazz());
        // For secondary tables.
        List<String> secondaryTables = ((DefaultEntityAnnotationProcessor) managedType.getEntityAnnotation())
                .getSecondaryTablesName();
        secondaryTables.add(m.getTableName());
        Collections.shuffle(secondaryTables);
        List<HBaseData> results = new ArrayList<HBaseData>();
        for (String colTableName : secondaryTables)
        {
            results.addAll(hbaseReader.LoadData(hTable, colTableName, rowKey, f, columns));
        }

        output = onRead(tableName, clazz, m, output, hTable, entity, relationNames, results);
        return output;
    }
391162
public int del(String tableName, String field, Object value) throws SQLException {
		return del(Entity.create(tableName).set(field, value));
	}
375626
private void setEntityIdValue(final Object entity, final BigDecimal id, final MappingColumn column) {
		Class<?> rawType = column.getJavaType().getRawType();
		if (int.class.equals(rawType) || Integer.class.equals(rawType)) {
			column.setValue(entity, id.intValue());
		} else if (long.class.equals(rawType) || Long.class.equals(rawType)) {
			column.setValue(entity, id.longValue());
		} else if (BigInteger.class.equals(rawType)) {
			column.setValue(entity, id.toBigInteger());
		} else if (BigDecimal.class.equals(rawType)) {
			column.setValue(entity, id);
		} else if (String.class.equals(rawType)) {
			column.setValue(entity, id.toPlainString());
		} else {
			throw new UroborosqlRuntimeException(
					"Column is not correct as ID type. column=" + column.getCamelName() + ", type=" + rawType);
		}
	}