All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.rx.bean.DataTable Maven / Gradle / Ivy

    package org.rx.bean;

import com.alibaba.fastjson.JSONObject;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.h2.expression.Alias;
import org.h2.expression.Expression;
import org.h2.expression.ExpressionColumn;
import org.h2.expression.aggregate.Aggregate;
import org.h2.expression.aggregate.AggregateType;
import org.h2.jdbc.JdbcConnection;
import org.h2.jdbc.JdbcResultSet;
import org.h2.result.LocalResult;
import org.h2.value.ValueToObjectConverter;
import org.rx.core.StringBuilder;
import org.rx.core.*;
import org.rx.exception.InvalidException;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import static org.rx.core.App.fromJson;
import static org.rx.core.Extends.*;

@Slf4j
@SuppressWarnings(Constants.NON_RAW_TYPES)
@NoArgsConstructor
public class DataTable implements Extends {
    private static final long serialVersionUID = -7379386582995440975L;
    public static final String HS_COLUMN_TYPE = "HS_COLUMN_TYPE";
    public static final String HS_COUNT_MAP = "HS_COUNT_MAP";

    public static DataTable read(ResultSet resultSet) {
        return read(resultSet, false);
    }

    @SneakyThrows
    public static DataTable read(ResultSet resultSet, boolean preferColumnName) {
        DataTable dt = new DataTable();
        try (ResultSet rs = resultSet) {
            ResultSetMetaData metaData = rs.getMetaData();
            dt.setTableName(metaData.getTableName(1));
            int columnCount = metaData.getColumnCount();
            for (int i = 1; i <= columnCount; i++) {
                dt.addColumn(preferColumnName ? metaData.getColumnName(i) : metaData.getColumnLabel(i));
            }

            List buf = new ArrayList<>(columnCount);
            while (rs.next()) {
                buf.clear();
                for (int i = 1; i <= columnCount; i++) {
                    buf.add(rs.getObject(i));
                }
                dt.addRow(buf.toArray());
            }
        }
        return dt;
    }

    @SneakyThrows
    public static DataTable read(JdbcResultSet resultSet) {
        DataTable dt = new DataTable();
        try (JdbcResultSet rs = resultSet) {
            LocalResult result = (LocalResult) rs.getResult();
            //包含orderby的
            Expression[] exprs = Reflects.readField(result, "expressions");
            if (exprs.length > 0) {
                dt.setTableName(exprs[0].getTableName());
            }
            for (Expression expr : exprs) {
                addColumnName(dt, expr);
            }

            JdbcConnection conn = Reflects.readField(rs, "conn");
            int columnCount = exprs.length;
            List buf = new ArrayList<>(columnCount);
            while (rs.next()) {
                buf.clear();
                for (int i = 1; i <= columnCount; i++) {
                    buf.add(ValueToObjectConverter.valueToDefaultObject(rs.getInternal(i), conn, true));
//                    buf.add(rs.getObject(i));
                }
                dt.addRow(buf.toArray());
            }
        }
        return dt;
    }

    static void addColumnName(DataTable dt, Expression expr) {
        if (tryAs(expr, ExpressionColumn.class, p -> {
            String col = p.getOriginalColumnName();
            if (col == null) {
                col = p.getColumn().getName();
            }
            dt.addColumns(col);
        }) || tryAs(expr, Aggregate.class, p -> {
            if (p.getAggregateType() == AggregateType.COUNT_ALL
                    || p.getAggregateType() == AggregateType.COUNT) {
                String label = p.toString();
                dt.addColumn(label);
                //todo COUNT with no label
                return;
            }
            Expression subExpr = p.getSubexpression(0);
            addColumnName(dt, subExpr);
        }) || tryAs(expr, Alias.class, p -> {
            Expression subExpr = p.getNonAliasExpression();
            Aggregate aggregate = as(subExpr, Aggregate.class);
            if (aggregate != null
                    && (aggregate.getAggregateType() == AggregateType.COUNT_ALL
                    || aggregate.getAggregateType() == AggregateType.COUNT)) {
                String label = p.getAlias(null, 0);
                dt.addColumn(label).attr(HS_COUNT_MAP, Tuple.of(subExpr.toString(), label));
                return;
            }
            addColumnName(dt, subExpr);
        })) ;
    }

    @Getter
    @Setter
    String tableName;
    final List columns = new ArrayList<>();
    List readOnlyColumns;
    final List rows = new ArrayList<>();
    @Setter
    Iterator fluentRows;

    public List> getColumns() {
        if (readOnlyColumns == null) {
            readOnlyColumns = Collections.unmodifiableList(columns);
        }
        return (List) readOnlyColumns;
    }

    public FluentIterable getRows() {
        return new FluentIterable() {
            Iterator cur = rows.iterator();
            final Iterator next = fluentRows;

            @Override
            public boolean hasNext() {
                if (!cur.hasNext()) {
                    if (cur == next || next == null) {
                        return false;
                    }
                    cur = next;
                    return hasNext();
                }
                return true;
            }

            @Override
            public DataRow next() {
                return cur.next();
            }
        };
    }

    public DataTable(String tableName) {
        this.tableName = tableName;
    }

    public  List toList(Class type) {
        List list = new ArrayList<>();
        Iterator rows = getRows();
        while (rows.hasNext()) {
            JSONObject item = new JSONObject(columns.size());
            List cells = rows.next().items;
            for (int i = 0; i < columns.size(); i++) {
                item.put(columns.get(i).columnName, cells.get(i));
            }
            list.add(fromJson(item, type));
        }
        return list;
    }

    public DataRow addRow(Object... items) {
        DataRow row = newRow(items);
        rows.add(row);
        return row;
    }

    public DataRow addRow(DataRow row) {
        if (row.table != this) {
            row = newRow(row.getArray());
        }
        rows.add(row);
        return row;
    }

    public DataRow removeRow(DataRow row) {
        rows.remove(row);
        return row;
    }

    public DataRow newRow(Object... items) {
        DataRow row = new DataRow(this);
        if (!Arrays.isEmpty(items)) {
            row.setArray(items);
        }
        return row;
    }

    public List> addColumns(String... columnNames) {
        List> columns = Linq.from(columnNames).select(this::addColumn).toList();
        return (List) columns;
    }

    public  DataColumn addColumn(String columnName) {
        DataColumn column = new DataColumn<>(this);
        column.ordinal = columns.size();
        column.columnName = columnName;
        columns.add(column);
        return column;
    }

    public  DataColumn removeColumn(String columnName) {
        int index = getColumn(columnName).ordinal;
        DataColumn column = columns.remove(index);
        for (DataRow row : rows) {
            row.items.remove(index);
        }
        return column;
    }

    public  DataColumn getColumn(int ordinal) {
        return columns.get(ordinal);
    }

    public  DataColumn getColumn(String columnName) {
        return Linq.from(columns).first(p -> eq(p.columnName, columnName));
    }

     void setOrdinal(DataColumn column, int ordinal) {
        if (fluentRows != null) {
            throw new InvalidException("Not supported");
        }
        if (column.ordinal == ordinal) {
            return;
        }

        columns.remove(ordinal);
        columns.add(ordinal, column);
        for (DataRow row : rows) {
            row.items.add(ordinal, row.items.remove(ordinal));
        }
        column.ordinal = ordinal;
    }

     DataColumn setDataType(DataColumn column, Class dataType) {
        if (fluentRows != null) {
            throw new InvalidException("Not supported");
        }
        if (Reflects.isAssignable(column.dataType, dataType)) {
            return (DataColumn) column;
        }

        for (DataRow row : rows) {
            row.items.set(column.ordinal, Reflects.changeType(row.items.get(column.ordinal), dataType));
        }
        column.dataType = dataType;
        return (DataColumn) column;
    }

    @Override
    public String toString() {
        StringBuilder txt = new StringBuilder();
        for (DataColumn column : getColumns()) {
            txt.append(column.getColumnName()).append("\t");
        }
        txt.appendLine();
        Iterator rows = getRows();
        while (rows.hasNext()) {
            for (Object item : rows.next().items) {
                txt.append(item).append("\t");
            }
            txt.appendLine();
        }
        return txt.toString();
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy