Get string inputs working

Author: pmenon

src/codegen/operator/csv_scan_translator.cpp

@@ -132,8 +132,16 @@ class CSVColumnAccess : public RowBatch::AttributeAccess {
                             llvm::Value *data_len) const {
     auto *input_func = SqlType().GetInputFunction(codegen, ai_->type);
     auto *raw_val = codegen.CallFunc(input_func, {type, data_ptr, data_len});
-    return codegen::Value{ai_->type, raw_val, nullptr,
-                          codegen.ConstBool(false)};
+    if (SqlType().IsVariableLength()) {
+      // StrWithLen
+      llvm::Value *str_ptr = codegen->CreateExtractValue(raw_val, 0);
+      llvm::Value *str_len = codegen->CreateExtractValue(raw_val, 1);
+      return codegen::Value{ai_->type, str_ptr, str_len,
+                            codegen.ConstBool(false)};
+    } else {
+      return codegen::Value{ai_->type, raw_val, nullptr,
+                            codegen.ConstBool(false)};
+    }
   }
 
   Value Access(CodeGen &codegen, UNUSED_ATTRIBUTE RowBatch::Row &row) override {

src/codegen/proxy/string_functions_proxy.cpp

@@ -14,6 +14,7 @@
 
 #include "codegen/proxy/executor_context_proxy.h"
 #include "codegen/proxy/pool_proxy.h"
+#include "codegen/proxy/runtime_functions_proxy.h"
 
 namespace peloton {
 namespace codegen {
@@ -32,6 +33,7 @@ DEFINE_METHOD(peloton::function, StringFunctions, Substr);
 DEFINE_METHOD(peloton::function, StringFunctions, Repeat);
 DEFINE_METHOD(peloton::function, StringFunctions, CompareStrings);
 DEFINE_METHOD(peloton::function, StringFunctions, WriteString);
+DEFINE_METHOD(peloton::function, StringFunctions, InputString);
 
 }  // namespace codegen
 }  // namespace peloton

src/codegen/type/varchar_type.cpp

@@ -597,9 +597,8 @@ void Varchar::GetTypeForMaterialization(CodeGen &codegen, llvm::Type *&val_type,
 }
 
 llvm::Function *Varchar::GetInputFunction(
-    UNUSED_ATTRIBUTE CodeGen &codegen,
-    UNUSED_ATTRIBUTE const Type &type) const {
-  throw NotImplementedException{"String input not implemented yet"};
+    CodeGen &codegen, UNUSED_ATTRIBUTE const Type &type) const {
+  return StringFunctionsProxy::InputString.GetFunction(codegen);
 }
 
 llvm::Function *Varchar::GetOutputFunction(

src/codegen/util/csv_scanner.cpp

@@ -197,6 +197,9 @@ const char *CSVScanner::NextLine() {
 
   uint32_t line_end = buffer_begin_;
 
+  char quote = quote_;
+  char escape = (quote_ == escape_ ? static_cast<char>('\0') : escape_);
+
   while (true) {
     if (line_end >= buffer_end_) {
       // We need to read more data from the CSV file. But first, we need to copy
@@ -219,13 +222,13 @@ const char *CSVScanner::NextLine() {
     // Read character
     char c = buffer_[line_end];
 
-    if (in_quote && c == escape_) {
-      last_was_escape = true;
+    if (in_quote && c == escape) {
+      last_was_escape = !last_was_escape;
     }
-    if (c == quote_ && !last_was_escape) {
-      in_quote = true;
+    if (c == quote && !last_was_escape) {
+      in_quote = !in_quote;
     }
-    if (c != escape_) {
+    if (c != escape) {
       last_was_escape = false;
     }
 

src/function/string_functions.cpp

@@ -245,5 +245,13 @@ void StringFunctions::WriteString(const char *data, uint32_t len, char *buf,
   *reinterpret_cast<Varlen **>(buf) = area;
 }
 
+// TODO(pmenon): UTF8 checking, string checking, lots of error handling here
+// TODO(pmenon): Why do we need this +1 on the length ?
+StringFunctions::StrWithLen StringFunctions::InputString(
+    UNUSED_ATTRIBUTE const codegen::type::Type &type, const char *data,
+    uint32_t len) {
+  return StringFunctions::StrWithLen{data, len + 1};
+}
+
 }  // namespace function
 }  // namespace peloton

src/include/codegen/proxy/string_functions_proxy.h

@@ -31,6 +31,7 @@ PROXY(StringFunctions) {
   DECLARE_METHOD(Repeat);
   DECLARE_METHOD(CompareStrings);
   DECLARE_METHOD(WriteString);
+  DECLARE_METHOD(InputString);
 };
 
 PROXY(StrWithLen) {

src/include/function/string_functions.h

@@ -16,6 +16,12 @@
 
 namespace peloton {
 
+namespace codegen {
+namespace type {
+class Type;
+}  // namespace type
+}  // namespace codegen
+
 namespace executor {
 class ExecutorContext;
 }  // namespace executor
@@ -104,6 +110,16 @@ class StringFunctions {
    */
   static void WriteString(const char *data, uint32_t len, char *buf,
                           peloton::type::AbstractPool &pool);
+
+  /**
+   *
+   * @param type
+   * @param data
+   * @param len
+   * @return
+   */
+  static StrWithLen InputString(const codegen::type::Type &type,
+                                const char *data, uint32_t len);
 };
 
 }  // namespace function

src/traffic_cop/traffic_cop.cpp

@@ -523,6 +523,11 @@ FieldInfo TrafficCop::GetColumnFieldForValueType(std::string column_name,
       field_size = 255;
       break;
     }
+    case type::TypeId::DATE: {
+      field_type = PostgresValueType::DATE;
+      field_size = 4;
+      break;
+    }
     case type::TypeId::TIMESTAMP: {
       field_type = PostgresValueType::TIMESTAMPS;
       field_size = 64;  // FIXME: Bytes???