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

    • net.dongliu.dbutils.sqlbuilder.BuilderMixin Maven / Gradle / Ivy

    package net.dongliu.dbutils.sqlbuilder;

import net.dongliu.commons.collection.Lists;
import net.dongliu.commons.collection.Pair;
import net.dongliu.dbutils.exception.SQLBuilderException;
import net.dongliu.dbutils.mapping.BeanMapping;
import net.dongliu.dbutils.mapping.BeanMappingUtils;

import javax.annotation.Nullable;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Collectors;

/**
 * Used to share code between SQLBuilder and HubNode
 *
 * @author Liu Dong
 */
public interface BuilderMixin> {
    /**
     * Get the hub node
     */
    HubNode hubNode();

    /**
     * Get self reference
     */
    T self();

    /**
     * Append new sql segment. Will insert white space if need
     */
    default T append(String sqlSegment) {
        if (sqlSegment.isEmpty()) {
            return self();
        }
        hubNode().addNode(new ClauseNode(sqlSegment));
        return self();
    }

    /**
     * Append new value.
     */
    default T param(@Nullable Object value) {
        hubNode().addNode(new ParamNode(value));
        return self();
    }

    /**
     * Append multi param, separated by ',' in sql clause
     */
    default T param(Object... values) {
        return param(Lists.of(values));
    }

    /**
     * Append multi param, separated by ',' in sql clause
     */
    default T param(Collection values) {
        hubNode().addNode(new ParamsNode(values));
        return self();
    }

    /**
     * Select
     */
    default T select(String name) {
        return append("SELECT " + name);
    }

    /**
     * Select
     */
    default T select(String... names) {
        return append("SELECT " + String.join(", ", (CharSequence[]) names));
    }

    /**
     * Select
     */
    default T select(Collection names) {
        return append("SELECT " + String.join(", ", names));
    }

    /**
     * From
     */
    default T from(String table) {
        return append("FROM " + table);
    }

    default T update(String table) {
        return append("UPDATE " + table);
    }

    /**
     * insert into
     */
    default T insertInto(String table, CharSequence... columns) {
        return append("INSERT INTO " + table + "(" + String.join(", ", columns) + ")");
    }

    /**
     * insert into
     */
    default T insertInto(String table, Collection columns) {
        return append("INSERT INTO " + table + "(" + String.join(", ", columns) + ")");
    }

    /**
     * Used with insert Into, set values
     */
    default T values(Object... values) {
        return values(Lists.of(values));
    }

    /**
     * Used with insert Into, set value
     */
    default T values(List values) {
        return append("VALUES(").param(values).append(")");
    }

    /**
     * Combine insert into and values
     */
    default T insertValues(String table, Map values) {
        return insertValues(table, values.entrySet());
    }

    /**
     * Combine insert into and values
     */
    default T insertValues(String table, Collection> values) {
        List columns = values.stream().map(v -> v.getKey()).collect(Collectors.toList());
        List vs = values.stream().map(v -> v.getValue()).collect(Collectors.toList());
        return insertInto(table, columns).values(vs);
    }

    default T deleteFrom(String table) {
        return append("DELETE FROM " + table);
    }

    /**
     * Note:limit not work for all database
     */
    default T limit(int offset, int len) {
        return append("LIMIT").param(offset).append(", ").param(len);
    }

    /**
     * Note:limit not work for all database
     */
    default T limit(int len) {
        return append("LIMIT").param(len);
    }

    default T offset(int offset) {
        return append("OFFSET").param(offset);
    }

    default T groupBy(String column) {
        return append("GROUP BY " + column);
    }

    default T orderBy(String column) {
        return append("ORDER BY " + column);
    }

    default T groupBy(CharSequence... columns) {
        return append("GROUP BY " + String.join(", ", columns));
    }

    default T orderBy(CharSequence... columns) {
        return append("ORDER BY " + String.join(", ", columns));
    }


    /**
     * in clause
     */
    default T in(Object... values) {
        return in(Lists.of(values));
    }

    /**
     * Sql in clause
     */
    default T in(Collection values) {
        return append("IN (").param(values).append(")");
    }

    /**
     * Build dynamic where
     */
    default T whereAllEquals(Map equalConditions) {
        return whereAllEquals(equalConditions.entrySet());
    }

    /**
     * Build dynamic where
     */
    default T whereAllEquals(Collection> equalConditions) {
        if (equalConditions.isEmpty()) {
            return self();
        }
        append("WHERE");
        int index = 0;
        for (Map.Entry equalCondition : equalConditions) {
            append(equalCondition.getKey() + " = ").param(equalCondition.getValue());
            if (index++ < equalConditions.size() - 1) {
                append("AND");
            }
        }
        return self();
    }

    /**
     * Build dynamic set
     */
    default T setAll(Map setValues) {
        return setAll(setValues.entrySet());
    }

    /**
     * Build dynamic set
     */
    default T setAll(Collection> setValues) {
        if (setValues.isEmpty()) {
            throw new SQLBuilderException("No set values");
        }
        append("SET");
        int index = 0;
        for (Map.Entry equalCondition : setValues) {
            append(equalCondition.getKey() + " = ").param(equalCondition.getValue());
            if (index++ < setValues.size() - 1) {
                append(",");
            }
        }
        return self();
    }

    /**
     * Generate select columns from bean class
     */
    default T selectBeanColumns(Class cls) {
        BeanMapping beanMapping = BeanMappingUtils.getBeanMapping(cls);
        Collection columns = beanMapping.columnNames();
        return select(columns);
    }


    /**
     * Generate insert clause via bean class
     */
    default T insertBean(String table, Object bean) {
        List> values = BeanMappingUtils.beanToEntries(bean);
        return insertValues(table, values);
    }

//    /**
//     * Build set sql for bean.
//     */
//    default T setBean(Object bean) {
//        List> values = BeanMappingUtils.beanToEntries(bean);
//        setAll(values);
//        return self();
//    }

}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy