br.com.objectos.way.sql.WaySql Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2014 Objectos, Fábrica de Software LTDA.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package br.com.objectos.way.sql;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import br.com.objectos.way.core.cache.TimeDuration;
import br.com.objectos.way.core.util.WayIterables;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

/**
 * @author [email protected] (Marcio Endo)
 */
public class WaySql {

  private WaySql() {
  }

  public static  Cache buildCache(
      Optional expireAfterAccess,
      Optional expireAfterWrite,
      long maximumSize) {
    CacheBuilder builder = CacheBuilder.newBuilder();

    if (expireAfterAccess.isPresent()) {
      TimeDuration duration = expireAfterAccess.get();
      builder = builder.expireAfterAccess(duration.duration(), duration.unit());
    }

    if (expireAfterWrite.isPresent()) {
      TimeDuration duration = expireAfterWrite.get();
      builder = builder.expireAfterWrite(duration.duration(), duration.unit());
    }

    if (maximumSize >= 0) {
      builder = builder.maximumSize(maximumSize);
    }

    return builder.build();
  }

  public static CountFunction count() {
    return CountFunction.get();
  }

  public static InsertValuesSql insertValues(HasTableInfo table) {
    TableInfo tableInfo = table.tableInfo();
    List columnInfoList = tableInfo.columnInfoList();
    List notGeneratedList = WayIterables.from(columnInfoList)
        .filter(ColumnInfoAutoIncrement.not())
        .toImmutableList();
    return InsertValuesSql.builder()
        .tableInfo(tableInfo)
        .columnInfoList(notGeneratedList)
        .generateKeys(columnInfoList.size() > notGeneratedList.size())
        .build();
  }

  public static IntegerColumnRef integerColumnRef() {
    return new IntegerColumnRef();
  }

  public static LocalDateColumnRef localDateColumnRef() {
    return new LocalDateColumnRef();
  }

  public static ResultFunction longFunction() {
    return LongResultFunction.INSTANCE;
  }

  public static SelectDef select(CanBeSelected first, CanBeSelected... others) {
    return SelectDefPojo.start(first, others);
  }

  public static ResultFunction stringFunction() {
    return StringResultFunction.INSTANCE;
  }

  public static SchemaDef use(String schemaName) {
    return new SchemaDefPojo(schemaName);
  }

  static void close(PreparedStatement statement) {
    if (statement != null) {
      try {
        statement.close();
      } catch (SQLException e) {
        //
      }
    }
  }

  static void close(ResultSet rs) {
    if (rs != null) {
      try {
        rs.close();
      } catch (SQLException e) {
        //
      }
    }
  }

  static String tableNameToClassName(String name) {
    Iterable words = Splitter.on('_').split(name);

    Iterable wordsNotEmptyCamelCase = WayIterables.from(words)
        .transform(new StringToLowerCase())
        .filter(new StringIsNotEmpty())
        .transform(new StringToUpperFirst())
        .toLazyIterable();

    return Joiner.on("").join(wordsNotEmptyCamelCase) + "Table";
  }

  private static enum LongResultFunction implements ResultFunction {
    INSTANCE;
    @Override
    public Long apply(Result input) {
      return input.getLong(1);
    }
  }

  private static class StringIsNotEmpty implements Predicate {
    @Override
    public boolean apply(String input) {
      return !input.isEmpty();
    }
  }

  private static enum StringResultFunction implements ResultFunction {
    INSTANCE;
    @Override
    public String apply(Result input) {
      return input.getString(1);
    }
  }

  private static class StringToLowerCase implements Function {
    @Override
    public String apply(String input) {
      return input.toLowerCase();
    }
  }

  private static class StringToUpperFirst implements Function {
    @Override
    public String apply(String input) {
      char first = input.charAt(0);
      char firstUpperCase = Character.toUpperCase(first);
      String substring = input.substring(1);
      return firstUpperCase + substring;
    }
  }

}