on conflict builder

Author: olirice

src/builder.rs

@@ -4,12 +4,19 @@ use crate::parser_util::*;
 use crate::sql_types::*;
 use graphql_parser::query::*;
 use serde::Serialize;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
 use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
 
+#[derive(Clone, Debug)]
+pub struct OnConflictBuilder {
+    pub constraint: Index, // Could probably get away with a name ref
+    pub update_fields: HashSet<Arc<Column>>, // Could probably get away with a name ref
+    pub filter: FilterBuilder,
+}
+
 #[derive(Clone, Debug)]
 pub struct InsertBuilder {
     pub alias: String,
@@ -22,6 +29,8 @@ pub struct InsertBuilder {
 
     //fields
     pub selections: Vec<InsertSelection>,
+
+    pub on_conflict: Option<OnConflictBuilder>,
 }
 
 #[derive(Clone, Debug)]
@@ -176,6 +185,90 @@ where
     parse_node_id(node_id_base64_encoded_json_string)
 }
 
+fn read_argument_on_conflict<'a, T>(
+    field: &__Field,
+    query_field: &graphql_parser::query::Field<'a, T>,
+    variables: &serde_json::Value,
+    variable_definitions: &Vec<VariableDefinition<'a, T>>,
+) -> Result<Option<OnConflictBuilder>, String>
+where
+    T: Text<'a> + Eq + AsRef<str>,
+{
+    let validated: gson::Value = read_argument(
+        "onConflict",
+        field,
+        query_field,
+        variables,
+        variable_definitions,
+    )?;
+
+    let insert_type: InsertOnConflictType = match field.get_arg("onConflict") {
+        None => return Ok(None),
+        Some(x) => match x.type_().unmodified_type() {
+            __Type::InsertOnConflictInput(insert_on_conflict) => insert_on_conflict,
+            _ => return Err("Could not locate Insert Entity type".to_string()),
+        },
+    };
+
+    let filter: FilterBuilder =
+        read_argument_filter(field, query_field, variables, variable_definitions)?;
+
+    let on_conflict_builder = match validated {
+        gson::Value::Absent | gson::Value::Null => None,
+        gson::Value::Object(contents) => {
+            let constraint = match contents
+                .get("constraint")
+                .expect("OnConflict revalidation error. Expected constraint")
+            {
+                gson::Value::String(ix_name) => insert_type
+                    .table
+                    .indexes
+                    .iter()
+                    .find(|ix| &ix.name == ix_name)
+                    .expect("OnConflict revalidation error. constraint: unknown constraint name"),
+                _ => {
+                    return Err(
+                        "OnConflict revalidation error. Expected constraint as String".to_string(),
+                    )
+                }
+            };
+
+            let update_fields = match contents
+                .get("updateFields")
+                .expect("OnConflict revalidation error. Expected updateFields")
+            {
+                gson::Value::Array(col_names) => {
+                    let mut update_columns: HashSet<Arc<Column>> = HashSet::new();
+                    for col_name in col_names {
+                        match col_name {
+                            gson::Value::String(c) => {
+                                let col = insert_type.table.columns.iter().find(|column| &column.name == c).expect("OnConflict revalidation error. updateFields: unknown column name");
+                                update_columns.insert(Arc::clone(col));
+                            }
+                            _ => return Err("OnConflict revalidation error. Expected updateFields to be column names".to_string()),
+                        }
+                    }
+                    update_columns
+                }
+                _ => {
+                    return Err(
+                        "OnConflict revalidation error. Expected updateFields to be an array"
+                            .to_string(),
+                    )
+                }
+            };
+
+            Some(OnConflictBuilder {
+                constraint: constraint.clone(),
+                update_fields,
+                filter,
+            })
+        }
+        _ => return Err("Insert re-validation errror".to_string()),
+    };
+    Ok(on_conflict_builder)
+}
+
 fn read_argument_objects<'a, T>(
     field: &__Field,
     query_field: &graphql_parser::query::Field<'a, T>,
@@ -277,11 +370,14 @@ where
     match &type_ {
         __Type::InsertResponse(xtype) => {
             // Raise for disallowed arguments
-            restrict_allowed_arguments(&["objects"], query_field)?;
+            restrict_allowed_arguments(&["objects", "onConflict"], query_field)?;
 
             let objects: Vec<InsertRowBuilder> =
                 read_argument_objects(field, query_field, variables, variable_definitions)?;
 
+            let on_conflict: Option<OnConflictBuilder> =
+                read_argument_on_conflict(field, query_field, variables, variable_definitions)?;
+
             let mut builder_fields: Vec<InsertSelection> = vec![];
 
             let selection_fields = normalize_selection_set(
@@ -324,6 +420,7 @@ where
                 table: Arc::clone(&xtype.table),
                 objects,
                 selections: builder_fields,
+                on_conflict,
             })
         }
         _ => Err(format!(