agoo 2.5.7 → 2.6.0

data/ext/agoo/gqljson.h

@@ -0,0 +1,15 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_GQLJSON_H
+#define AGOO_GQLJSON_H
+
+
+#include <stdlib.h>
+
+#include "err.h"
+
+struct _gqlValue;
+
+extern struct _gqlValue*	gql_json_parse(agooErr err, const char *json, size_t len);
+
+#endif // AGOO_GQLJSON_H

data/ext/agoo/gqlvalue.c

@@ -8,10 +8,11 @@
 #include "debug.h"
 #include "gqlvalue.h"
 #include "graphql.h"
+#include "sectime.h"
 
 static const char	spaces[256] = "\n                                                                                                                                                                                                                                                               ";
 
-// Int type
+// Null type
 static agooText
 null_to_text(agooText text, gqlValue value, int indent, int depth) {
     return agoo_text_append(text, "null", 4);
@@ -21,11 +22,11 @@ struct _gqlType	gql_null_type = {
     .name = "Null",
     .desc = "Null scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_NULL,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = null_to_text,
+    .to_sdl = null_to_text,
 };
 
 // Int type
@@ -43,11 +44,11 @@ struct _gqlType	gql_int_type = {
     .name = "Int",
     .desc = "Int scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_INT,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = int_to_text,
+    .to_sdl = int_to_text,
 };
 
 // I64 type, add on type.
@@ -65,60 +66,98 @@ struct _gqlType	gql_i64_type = {
     .name = "I64",
     .desc = "64 bit integer scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_I64,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = i64_to_text,
+    .to_sdl = i64_to_text,
 };
 
 // String type
 static void
 string_destroy(gqlValue value) {
-    free((char*)value->str);
+    if (value->str.alloced) {
+	AGOO_FREE((char*)value->str.ptr);
+    }
 }
 
-static agooText	string_to_text(agooText text, gqlValue value, int indent, int depth);
+static agooText
+string_to_text(agooText text, gqlValue value, int indent, int depth) {
+    if (!value->str.alloced) {
+	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append_json(text, value->str.a, -1);
+	text = agoo_text_append(text, "\"", 1);
+    } else if (NULL == value->str.ptr) {
+	text = agoo_text_append(text, "null", 4);
+    } else {
+	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append_json(text, value->str.ptr, -1);
+	text = agoo_text_append(text, "\"", 1);
+    }
+    return text;
+}
 
 struct _gqlType	gql_string_type = {
     .name = "String",
     .desc = "String scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_STRING,
     .core = true,
-    .coerce = NULL,
     .destroy = string_destroy,
     .to_json = string_to_text,
+    .to_sdl = string_to_text,
 };
 
-// Alternative to String but with no destroy needed.
-struct _gqlType	gql_str16_type = { // unregistered
-    .name = "str16",
-    .desc = NULL,
+// Token type
+static agooText
+token_to_text(agooText text, gqlValue value, int indent, int depth) {
+    if (!value->str.alloced) {
+	text = agoo_text_append_json(text, value->str.a, -1);
+    } else if (NULL == value->str.ptr) {
+	text = agoo_text_append(text, "null", 4);
+    } else {
+	text = agoo_text_append_json(text, value->str.ptr, -1);
+    }
+    return text;
+}
+
+struct _gqlType	gql_token_type = {
+    .name = "Token",
+    .desc = "Token scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_TOKEN,
     .core = true,
-    .coerce = NULL,
-    .destroy = NULL,
+    .destroy = string_destroy,
     .to_json = string_to_text,
+    .to_sdl = token_to_text,
 };
 
+// Variable type ($var)
 static agooText
-string_to_text(agooText text, gqlValue value, int indent, int depth) {
-    if (&gql_str16_type == value->type) {
-	text = agoo_text_append(text, "\"", 1);
-	text = agoo_text_append(text, value->str16, -1);
-	text = agoo_text_append(text, "\"", 1);
-    } else if (NULL == value->str) {
+var_to_text(agooText text, gqlValue value, int indent, int depth) {
+    if (!value->str.alloced) {
+	text = agoo_text_append_char(text, '%');
+	text = agoo_text_append_json(text, value->str.a, -1);
+    } else if (NULL == value->str.ptr) {
 	text = agoo_text_append(text, "null", 4);
     } else {
-	text = agoo_text_append(text, "\"", 1);
-	text = agoo_text_append(text, value->str, -1);
-	text = agoo_text_append(text, "\"", 1);
+	text = agoo_text_append_char(text, '%');
+	text = agoo_text_append_json(text, value->str.ptr, -1);
     }
     return text;
 }
 
+struct _gqlType	gql_var_type = {
+    .name = "Var",
+    .desc = "Variable scalar.",
+    .kind = GQL_SCALAR,
+    .scalar_kind = GQL_SCALAR_VAR,
+    .core = true,
+    .destroy = string_destroy,
+    .to_json = var_to_text,
+    .to_sdl = var_to_text,
+};
+
 // Bool type
 static agooText
 bool_to_text(agooText text, gqlValue value, int indent, int depth) {
@@ -134,11 +173,11 @@ struct _gqlType	gql_bool_type = {
     .name = "Boolean",
     .desc = "Boolean scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_BOOL,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = bool_to_text,
+    .to_sdl = bool_to_text,
 };
 
 // Float type
@@ -156,11 +195,11 @@ struct _gqlType	gql_float_type = {
     .name = "Float",
     .desc = "Float scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_FLOAT,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = float_to_text,
+    .to_sdl = float_to_text,
 };
 
 // Time type
@@ -412,20 +451,18 @@ time_parse(agooErr err, const char *str, int len) {
 
 static agooText
 time_to_text(agooText text, gqlValue value, int indent, int depth) {
-    char	str[64];
-    int		cnt;
-    struct tm	tm;
-    int64_t	tt = value->time;
-    time_t	t = (time_t)(tt / 1000000000LL);
-    long	nsecs = tt - (int64_t)t * 1000000000LL;
+    char		str[64];
+    int			cnt;
+    struct _agooTime	at;
+    int64_t		tt = value->time;
+    time_t		t = (time_t)(tt / 1000000000LL);
+    long		nsecs = tt - (int64_t)t * 1000000000LL;
 
     if (0 > nsecs) {
 	nsecs = -nsecs;
     }
-    gmtime_r(&t, &tm);
-    cnt = sprintf(str, "\"%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ\"",
-		  1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
-		  tm.tm_hour, tm.tm_min, tm.tm_sec, (long)nsecs);
+    agoo_sectime(t, &at);
+    cnt = sprintf(str, "\"%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ\"", at.year, at.mon, at.day, at.hour, at.min, at.sec, (long)nsecs);
     
     return agoo_text_append(text, str, cnt);
 }
@@ -434,11 +471,11 @@ struct _gqlType	gql_time_type = {
     .name = "Time",
     .desc = "Time zulu scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_TIME,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = time_to_text,
+    .to_sdl = time_to_text,
 };
 
 // Uuid type
@@ -527,40 +564,11 @@ struct _gqlType	gql_uuid_type = {
     .name = "Uuid",
     .desc = "UUID scalar.",
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_UUID,
     .core = true,
-    .coerce = NULL,
     .destroy = NULL,
     .to_json = uuid_to_text,
-};
-
-// Url type
-static void
-url_destroy(gqlValue value) {
-    free((char*)value->url);
-}
-
-static agooText
-url_to_text(agooText text, gqlValue value, int indent, int depth) {
-    if (NULL == value->url) {
-	return agoo_text_append(text, "null", 4);
-    }
-    text = agoo_text_append(text, "\"", 1);
-    text = agoo_text_append(text, value->url, -1);
-    text = agoo_text_append(text, "\"", 1);
-
-    return text;
-}
-
-struct _gqlType	gql_url_type = {
-    .name = "Url",
-    .desc = "URL scalar.",
-    .kind = GQL_SCALAR,
-    .locked = true,
-    .core = true,
-    .coerce = NULL,
-    .destroy = url_destroy,
-    .to_json = url_to_text,
+    .to_sdl = uuid_to_text,
 };
 
 // List, not visible but used for list values.
@@ -571,8 +579,7 @@ list_destroy(gqlValue value) {
     while (NULL != (link = value->members)) {
 	value->members = link->next;
 	gql_value_destroy(link->value);
-	DEBUG_ALLOC(mem_graphql_link, link);
-	free(link);
+	AGOO_FREE(link);
     }
 }
 
@@ -582,7 +589,40 @@ list_to_json(agooText text, gqlValue value, int indent, int depth) {
     int		i2 = i + indent;
     int		d2 = depth + 1;
     gqlLink	link;
-    
+
+    if (0 < indent) {
+	i++; // for \n
+	i2++;
+    }
+    if ((int)sizeof(spaces) <= i) {
+	i2 = sizeof(spaces) - 1;
+	i = i2 - indent;
+    }
+    text = agoo_text_append(text, "[", 1);
+    for (link = value->members; NULL != link; link = link->next) {
+	if (0 < i2) {
+	    text = agoo_text_append(text, spaces, i2);
+	}
+	text = gql_value_json(text, link->value, indent, d2);
+	if (NULL != link->next) {
+	    text = agoo_text_append(text, ",", 1);
+	}
+    }
+    if (0 < indent) {
+	text = agoo_text_append(text, spaces, i);
+    }
+    text = agoo_text_append(text, "]", 1);
+
+    return text;
+}
+
+static agooText
+list_to_sdl(agooText text, gqlValue value, int indent, int depth) {
+    int		i = indent * depth;
+    int		i2 = i + indent;
+    int		d2 = depth + 1;
+    gqlLink	link;
+
     if (0 < indent) {
 	i++; // for \n
 	i2++;
@@ -593,8 +633,10 @@ list_to_json(agooText text, gqlValue value, int indent, int depth) {
     }
     text = agoo_text_append(text, "[", 1);
     for (link = value->members; NULL != link; link = link->next) {
-	text = agoo_text_append(text, spaces, i2);
-	text = link->value->type->to_json(text, link->value, indent, d2);
+	if (0 < i2) {
+	    text = agoo_text_append(text, spaces, i2);
+	}
+	text = link->value->type->to_sdl(text, link->value, indent, d2);
 	if (NULL != link->next) {
 	    text = agoo_text_append(text, ",", 1);
 	}
@@ -611,11 +653,11 @@ struct _gqlType	list_type = { // unregistered
     .name = "__List",
     .desc = NULL,
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_LIST,
     .core = true,
-    .coerce = NULL,
     .destroy = list_destroy,
     .to_json = list_to_json,
+    .to_sdl = list_to_sdl,
 };
 
 // Object, not visible but used for object values.
@@ -626,14 +668,13 @@ object_destroy(gqlValue value) {
     while (NULL != (link = value->members)) {
 	value->members = link->next;
 	gql_value_destroy(link->value);
-	free(link->key);
-	DEBUG_ALLOC(mem_graphql_link, link);
-	free(link);
+	AGOO_FREE(link->key);
+	AGOO_FREE(link);
     }
 }
 
-static agooText
-object_to_json(agooText text, gqlValue value, int indent, int depth) {
+agooText
+gql_object_to_json(agooText text, gqlValue value, int indent, int depth) {
     int		i = indent * depth;
     int		i2 = i + indent;
     int		d2 = depth + 1;
@@ -649,15 +690,56 @@ object_to_json(agooText text, gqlValue value, int indent, int depth) {
     }
     text = agoo_text_append(text, "{", 1);
     for (link = value->members; NULL != link; link = link->next) {
-	text = agoo_text_append(text, spaces, i2);
+	if (0 < i2) {
+	    text = agoo_text_append(text, spaces, i2);
+	}
 	text = agoo_text_append(text, "\"", 1);
 	text = agoo_text_append(text, link->key, -1);
 	if (0 < indent) {
-	    text = agoo_text_append(text, "\": ", 3);
+	    text = agoo_text_append(text, "\":", 2);
 	} else {
 	    text = agoo_text_append(text, "\":", 2);
 	}
-	text = link->value->type->to_json(text, link->value, indent, d2);
+	text = gql_value_json(text, link->value, indent, d2);
+	if (NULL != link->next) {
+	    text = agoo_text_append(text, ",", 1);
+	}
+    }
+    if (0 < indent) {
+	text = agoo_text_append(text, spaces, i);
+    }
+    text = agoo_text_append(text, "}", 1);
+
+    return text;
+}
+
+agooText
+gql_object_to_sdl(agooText text, gqlValue value, int indent, int depth) {
+    int		i = indent * depth;
+    int		i2 = i + indent;
+    int		d2 = depth + 1;
+    gqlLink	link;
+    
+    if (0 < indent) {
+	i++; // for \n
+	i2++;
+    }
+    if ((int)sizeof(spaces) <= i) {
+	i2 = sizeof(spaces) - 1;
+	i = i2 - indent;
+    }
+    text = agoo_text_append(text, "{", 1);
+    for (link = value->members; NULL != link; link = link->next) {
+	if (0 < i2) {
+	    text = agoo_text_append(text, spaces, i2);
+	}
+	text = agoo_text_append(text, link->key, -1);
+	if (0 < indent) {
+	    text = agoo_text_append(text, ": ", 2);
+	} else {
+	    text = agoo_text_append(text, ":", 1);
+	}
+	text = link->value->type->to_sdl(text, link->value, indent, d2);
 	if (NULL != link->next) {
 	    text = agoo_text_append(text, ",", 1);
 	}
@@ -674,21 +756,29 @@ struct _gqlType	object_type = { // unregistered
     .name = "__Object",
     .desc = NULL,
     .kind = GQL_SCALAR,
-    .locked = true,
+    .scalar_kind = GQL_SCALAR_OBJECT,
     .core = true,
-    .coerce = NULL,
     .destroy = object_destroy,
-    .to_json = object_to_json,
+    .to_json = gql_object_to_json,
+    .to_sdl = gql_object_to_sdl,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 void
 gql_value_destroy(gqlValue value) {
-    if (NULL != value->type->destroy) {
-	value->type->destroy(value);
+    if (NULL != value) {
+	if (GQL_SCALAR == value->type->kind) {
+	    if (NULL != value->type->destroy) {
+		value->type->destroy(value);
+	    }
+	} else if (GQL_ENUM == value->type->kind) {
+	    // TBD destroy string
+	    string_destroy(value);
+	} else {
+	    return;
+	}
+	AGOO_FREE(value);
     }
-    DEBUG_ALLOC(mem_graphql_value, value);
-    free(value);
 }
 
 int
@@ -699,7 +789,6 @@ gql_value_init(agooErr err) {
 	AGOO_ERR_OK != gql_type_set(err, &gql_float_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_time_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_uuid_type) ||
-	AGOO_ERR_OK != gql_type_set(err, &gql_url_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_string_type)) {
 	return err->code;
     }
@@ -723,16 +812,18 @@ int
 gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
     value->type = &gql_string_type;
     if (NULL == str) {
-	value->str = NULL;
+	value->str.alloced = true;
+	value->str.ptr = NULL;
     } else {
 	if (0 >= len) {
 	    len = (int)strlen(str);
 	}
-	if (len < (int)sizeof(value->str16)) {
-	    value->type = &gql_str16_type;
-	    strncpy(value->str16, str, len);
+	if (len < (int)sizeof(value->str.a)) {
+	    strncpy(value->str.a, str, len);
+	    value->str.alloced = false;
 	} else {
-	    if (NULL == (value->str = strndup(str, len))) {
+	    value->str.alloced = true;
+	    if (NULL == (value->str.ptr = AGOO_STRNDUP(str, len))) {
 		return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
 	    }
 	}
@@ -741,16 +832,23 @@ gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
 }
 
 int
-gql_url_set(agooErr err, gqlValue value, const char *url, int len) {
-    value->type = &gql_url_type;
-    if (NULL == url) {
-	value->url = NULL;
+gql_token_set(agooErr err, gqlValue value, const char *str, int len) {
+    value->type = &gql_token_type;
+    if (NULL == str) {
+	value->str.alloced = true;
+	value->str.ptr = NULL;
     } else {
 	if (0 >= len) {
-	    len = (int)strlen(url);
+	    len = (int)strlen(str);
 	}
-	if (NULL == (value->url = strndup(url, len))) {
-	    return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+	if (len < (int)sizeof(value->str.a)) {
+	    strncpy(value->str.a, str, len);
+	    value->str.alloced = false;
+	} else {
+	    value->str.alloced = true;
+	    if (NULL == (value->str.ptr = AGOO_STRNDUP(str, len))) {
+		return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+	    }
 	}
     }
     return AGOO_ERR_OK;
@@ -758,21 +856,25 @@ gql_url_set(agooErr err, gqlValue value, const char *url, int len) {
 
 void
 gql_bool_set(gqlValue value, bool b) {
+    value->type = &gql_bool_type;
     value->b = b;
 }
 
 void
 gql_float_set(gqlValue value, double f) {
+    value->type = &gql_float_type;
     value->f = f;
 }
 
 void
 gql_time_set(gqlValue value, int64_t t) {
+    value->type = &gql_time_type;
     value->time = t;
 }
 
 int
 gql_time_str_set(agooErr err, gqlValue value, const char *str, int len) {
+    value->type = &gql_time_type;
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -783,6 +885,7 @@ gql_time_str_set(agooErr err, gqlValue value, const char *str, int len) {
 
 void
 gql_uuid_set(gqlValue value, uint64_t hi, uint64_t lo) {
+    value->type = &gql_uuid_type;
     value->uuid.hi = hi;
     value->uuid.lo = lo;
 }
@@ -795,6 +898,7 @@ gql_uuid_str_set(agooErr err, gqlValue value, const char *str, int len) {
     if (AGOO_ERR_OK != parse_uuid(err, str, len, &hi, &lo)) {
 	return err->code;
     }
+    value->type = &gql_uuid_type;
     value->uuid.hi = hi;
     value->uuid.lo = lo;
 
@@ -804,23 +908,37 @@ gql_uuid_str_set(agooErr err, gqlValue value, const char *str, int len) {
 extern void	gql_null_set(gqlValue value);
 
 gqlLink
-link_create(agooErr err, gqlValue item) {
-    gqlLink	link = (gqlLink)malloc(sizeof(struct _gqlLink));
+gql_link_create(agooErr err, const char *key, gqlValue item) {
+    gqlLink	link = (gqlLink)AGOO_MALLOC(sizeof(struct _gqlLink));
 
     if (NULL == link) {
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a list link.");
     } else {
-	DEBUG_ALLOC(mem_graphql_link, link);
 	link->next = NULL;
 	link->key = NULL;
+	if (NULL != key) {
+	    if (NULL == (link->key = AGOO_STRDUP(key))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup() failed.");
+		return NULL;
+	    }
+	}
 	link->value = item;
     }
     return link;
 }
 
+void
+gql_link_destroy(gqlLink link) {
+    AGOO_FREE(link->key);
+    if (NULL != link->value) {
+	gql_value_destroy(link->value);
+    }
+    AGOO_FREE(link);
+}
+
 int
 gql_list_append(agooErr err, gqlValue list, gqlValue item) {
-    gqlLink	link = link_create(err, item);
+    gqlLink	link = gql_link_create(err, NULL, item);
 
     if (NULL != link) {
 	if (NULL == list->members) {
@@ -838,7 +956,7 @@ gql_list_append(agooErr err, gqlValue list, gqlValue item) {
 
 int
 gql_list_prepend(agooErr err, gqlValue list, gqlValue item) {
-    gqlLink	link = link_create(err, item);
+    gqlLink	link = gql_link_create(err, NULL, item);
 
     if (NULL != link) {
 	link->next = list->members;
@@ -849,10 +967,9 @@ gql_list_prepend(agooErr err, gqlValue list, gqlValue item) {
 
 int
 gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
-    gqlLink	link = link_create(err, item);
+    gqlLink	link = gql_link_create(err, key, item);
 
     if (NULL != link) {
-	link->key = strdup(key);
 	//link->next = obj->members;
 	if (NULL == obj->members) {
 	    obj->members = link;
@@ -871,10 +988,9 @@ gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
 
 static gqlValue
 value_create(gqlType type) {
-    gqlValue	v = (gqlValue)malloc(sizeof(struct _gqlValue));
+    gqlValue	v = (gqlValue)AGOO_MALLOC(sizeof(struct _gqlValue));
     
     if (NULL != v) {
-	DEBUG_ALLOC(mem_graphql_value, v);
 	memset(v, 0, sizeof(struct _gqlValue));
 	v->type = type;
     }
@@ -908,35 +1024,67 @@ gql_string_create(agooErr err, const char *str, int len) {
     if (0 >= len) {
 	len = (int)strlen(str);
     }
-    if ((int)sizeof(v->str16) <= len) {
-	if (NULL != (v = value_create(&gql_string_type))) {
-	    if (NULL == (v->str = strndup(str, len))) {
+    if (NULL != (v = value_create(&gql_string_type))) {
+	if ((int)sizeof(v->str.a) <= len) {
+	    v->str.alloced = true;
+	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
 		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
 		return NULL;
 	    }
+	} else {
+	    v->str.alloced = false;
+	    strncpy(v->str.a, str, len);
+	    v->str.a[len] = '\0';
 	}
-    } else {
-	if (NULL != (v = value_create(&gql_str16_type))) {
-	    strncpy(v->str16, str, len);
-	    v->str16[len] = '\0';
+    }
+    return v;
+}
+
+gqlValue
+gql_token_create(agooErr err, const char *str, int len, gqlType type) {
+    gqlValue	v;
+    
+    if (0 >= len) {
+	len = (int)strlen(str);
+    }
+    if (NULL == type || GQL_ENUM != type->kind) {
+	type = &gql_token_type;
+    }
+    if (NULL != (v = value_create(type))) {
+	if ((int)sizeof(v->str.a) <= len) {
+	    v->str.alloced = true;
+	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		return NULL;
+	    }
+	} else {
+	    v->str.alloced = false;
+	    strncpy(v->str.a, str, len);
+	    v->str.a[len] = '\0';
 	}
     }
     return v;
 }
 
 gqlValue
-gql_url_create(agooErr err, const char *url, int len) {
-    gqlValue	v = value_create(&gql_url_type);
+gql_var_create(agooErr err, const char *str, int len) {
+    gqlValue	v;
     
     if (0 >= len) {
-	len = (int)strlen(url);
+	len = (int)strlen(str);
     }
-    if (NULL != v) {
-	if (NULL == (v->str = strndup(url, len))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
-	    return NULL;
+    if (NULL != (v = value_create(&gql_var_type))) {
+	if ((int)sizeof(v->str.a) <= len) {
+	    v->str.alloced = true;
+	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		return NULL;
+	    }
+	} else {
+	    v->str.alloced = false;
+	    strncpy(v->str.a, str, len);
+	    v->str.a[len] = '\0';
 	}
-	    
     }
     return v;
 }
@@ -1020,12 +1168,12 @@ gql_null_create(agooErr err) {
 }
 
 gqlValue
-gql_list_create(agooErr err, gqlType itemType) {
+gql_list_create(agooErr err, gqlType item_type) {
     gqlValue	v = value_create(&list_type);
 
     if (NULL != v) {
 	v->members = NULL;
-	v->member_type = itemType;
+	v->member_type = item_type;
     }
     return v;
 }
@@ -1043,5 +1191,400 @@ gql_object_create(agooErr err) {
 
 agooText
 gql_value_json(agooText text, gqlValue value, int indent, int depth) {
-    return value->type->to_json(text, value, indent, depth);
+    if (NULL == value->type || GQL_SCALAR != value->type->kind) {
+	if (GQL_ENUM == value->type->kind) {
+	    text = string_to_text(text, value, indent, depth);
+	} else {
+	    text = agoo_text_append(text, "null", 4);
+	}
+    } else if (NULL == value->type->to_json) {
+	text = agoo_text_append(text, "null", 4);
+    } else {
+	text = value->type->to_json(text, value, indent, depth);
+    }
+    return text;
+}
+
+agooText
+gql_value_sdl(agooText text, gqlValue value, int indent, int depth) {
+    if (NULL == value->type || GQL_SCALAR != value->type->kind) {
+	if (GQL_ENUM == value->type->kind) {
+	    text = token_to_text(text, value, indent, depth);
+	} else {
+	    text = agoo_text_append(text, "null", 4);
+	}
+    } else if (NULL == value->type->to_sdl) {
+	text = agoo_text_append(text, "null", 4);
+    } else {
+	text = value->type->to_sdl(text, value, indent, depth);
+    }
+    return text;
+}
+
+const char*
+gql_string_get(gqlValue value) {
+    const char	*s = NULL;
+
+    if (NULL != value) {
+	if (&gql_string_type == value->type || &gql_token_type == value->type || &gql_var_type == value->type ||
+	    GQL_ENUM == value->type->kind) {
+	    if (value->str.alloced) {
+		s = value->str.ptr;
+	    } else {
+		s = value->str.a;
+	    }
+	}
+    }
+    return s;
+}
+
+static int
+convert_to_bool(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_INT:
+	gql_bool_set(value, 0 != value->i);
+	break;
+    case GQL_SCALAR_I64:
+	gql_bool_set(value, 0 != value->i64);
+	break;
+    case GQL_SCALAR_FLOAT:
+	gql_bool_set(value, 0.0 != value->f);
+	break;
+    case GQL_SCALAR_STRING:
+    case GQL_SCALAR_TOKEN: {
+	const char	*s = gql_string_get(value);
+	
+	value->type = &gql_bool_type;
+	if (0 == strcasecmp("true", s)) {
+	    value->b = true;
+	} else if (0 == strcasecmp("false", s)) {
+	    value->b = false;
+	} else {
+	    agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a String of '%s' into a Boolean value.", s);
+	}
+	if (value->str.alloced) {
+	    AGOO_FREE((char*)value->str.ptr);
+	}
+	break;
+    }
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a Boolean value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_int(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_I64:
+	if (value->i64 < INT32_MIN || INT32_MAX < value->i64) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a %lld into an Int value. Out of range.", (long long)value->i64);
+	} else {
+	    gql_int_set(value, (int32_t)value->i64);
+	}
+	break;
+    case GQL_SCALAR_FLOAT:
+	if (value->f < (double)INT32_MIN || (double)INT32_MAX < value->f) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a %g into an Int value. Out of range.", value->f);
+	} else if ((double)(int32_t)value->f != value->f) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a %g into an Int value. Loss of precision.", value->f);
+	} else {
+	    gql_int_set(value, (int32_t)value->f);
+	}
+	break;
+    case GQL_SCALAR_STRING: {
+	const char	*s = gql_string_get(value);
+	char		*end;
+	long		i = strtol(s, &end, 10);
+
+	if ('\0' != *end || (0 == i && 0 != errno)) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a '%s' into an Int value.", s);
+	} else if (i < INT32_MIN || INT32_MAX < i) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a %lld into an Int value. Out of range.", (long long)i);
+	} else {
+	    gql_int_set(value, (int32_t)i);
+	    if (value->str.alloced) {
+		AGOO_FREE((char*)value->str.ptr);
+	    }
+	}
+	break;
+    }
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into an Int value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_i64(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_INT:
+	gql_i64_set(value, (int64_t)value->i);
+	break;
+    case GQL_SCALAR_FLOAT:
+	if ((double)(int64_t)value->f != value->f) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a %g into an I64 value. Loss of precision.", value->f);
+	} else {
+	    gql_i64_set(value, (int64_t)value->f);
+	}
+	break;
+    case GQL_SCALAR_STRING: {
+	const char	*s = gql_string_get(value);
+	char		*end;
+	long long	i = strtoll(s, &end, 10);
+
+	if ('\0' != *end || (0 == i && 0 != errno)) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a '%s' into an I64 value.", s);
+	} else {
+	    gql_i64_set(value, (int64_t)i);
+	    if (value->str.alloced) {
+		AGOO_FREE((char*)value->str.ptr);
+	    }
+	}
+	break;
+    }
+    case GQL_SCALAR_TIME:
+	gql_i64_set(value, (int64_t)value->time);
+	break;
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into an I64 value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_float(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_INT:
+	gql_float_set(value, (double)value->i);
+	break;
+    case GQL_SCALAR_I64:
+	gql_float_set(value, (double)value->i64);
+	break;
+    case GQL_SCALAR_STRING: {
+	const char	*s = gql_string_get(value);
+	char		*end;
+	double		d = strtod(s, &end);
+
+	if ('\0' != *end) {
+	    agoo_err_set(err, ERANGE, "Can not coerce a '%s' into a Float value.", s);
+	} else {
+	    gql_float_set(value, d);
+	    if (value->str.alloced) {
+		AGOO_FREE((char*)value->str.ptr);
+	    }
+	}
+	break;
+    }
+    case GQL_SCALAR_TIME:
+	gql_float_set(value, (double)value->time / 1000000000.0);
+	break;
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a Float value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_string(agooErr err, gqlValue value) {
+    char	buf[64];
+    int		cnt;
+    
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_BOOL:
+	if (value->b) {
+	    gql_string_set(err, value, "true", 4);
+	} else {
+	    gql_string_set(err, value, "false", 5);
+	}
+	break;
+    case GQL_SCALAR_INT:
+	cnt = sprintf(buf, "%d", value->i);
+	gql_string_set(err, value, buf, cnt);
+	break;
+    case GQL_SCALAR_I64:
+	cnt = sprintf(buf, "%lld", (long long)value->i64);
+	gql_string_set(err, value, buf, cnt);
+	break;
+    case GQL_SCALAR_FLOAT:
+	cnt = sprintf(buf, "%g", value->f);
+	gql_string_set(err, value, buf, cnt);
+	break;
+    case GQL_SCALAR_TOKEN:
+	value->type = &gql_string_type;
+	break;
+    case GQL_SCALAR_TIME: {
+	struct _agooTime	at;
+	int64_t			tt = value->time;
+	time_t			t = (time_t)(tt / 1000000000LL);
+	long			nsecs = tt - (int64_t)t * 1000000000LL;
+
+	if (0 > nsecs) {
+	    nsecs = -nsecs;
+	}
+	agoo_sectime(t, &at);
+	cnt = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ", at.year, at.mon, at.day, at.hour, at.min, at.sec, (long)nsecs);
+	gql_string_set(err, value, buf, cnt);
+	break;
+    }
+    case GQL_SCALAR_UUID:
+	cnt = sprintf(buf, "%08lx-%04lx-%04lx-%04lx-%012lx",
+		      (unsigned long)(value->uuid.hi >> 32),
+		      (unsigned long)((value->uuid.hi >> 16) & 0x000000000000FFFFUL),
+		      (unsigned long)(value->uuid.hi & 0x000000000000FFFFUL),
+		      (unsigned long)(value->uuid.lo >> 48),
+		      (unsigned long)(value->uuid.lo & 0x0000FFFFFFFFFFFFUL));
+	gql_string_set(err, value, buf, cnt);
+	break;
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a String value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_token(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_STRING:
+	value->type = &gql_token_type;
+	break;
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a token value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_time(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_I64:
+	gql_time_set(value, value->i64);
+	break;
+    case GQL_SCALAR_STRING: {
+	int64_t	nsecs = time_parse(err, gql_string_get(value), -1);
+
+	if (AGOO_ERR_OK == err->code) {
+	    if (value->str.alloced) {
+		AGOO_FREE((char*)value->str.ptr);
+	    }
+	    gql_time_set(value, nsecs);
+	}
+	break;
+    }
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a Time value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+static int
+convert_to_uuid(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_STRING: {
+	const char	*s = gql_string_get(value);
+	bool		alloced = value->str.alloced;
+	
+	if (AGOO_ERR_OK == gql_uuid_str_set(err, value, s, 0)) {
+	    if (alloced) {
+		AGOO_FREE((char*)s);
+	    }
+	}
+	break;
+    }
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a UUID value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
+int
+gql_value_convert(agooErr err, gqlValue value, struct _gqlType *type) {
+    int	code = AGOO_ERR_OK;
+    
+    if (type != value->type) {
+	switch (type->scalar_kind) {
+	case GQL_SCALAR_BOOL:
+	    code = convert_to_bool(err, value);
+	    break;
+	case GQL_SCALAR_INT:
+	    code = convert_to_int(err, value);
+	    break;
+	case GQL_SCALAR_I64:
+	    code = convert_to_i64(err, value);
+	    break;
+	case GQL_SCALAR_FLOAT:
+	    code = convert_to_float(err, value);
+	    break;
+	case GQL_SCALAR_STRING:
+	    code = convert_to_string(err, value);
+	    break;
+	case GQL_SCALAR_TOKEN:
+	    code = convert_to_token(err, value);
+	    break;
+	case GQL_SCALAR_TIME:
+	    code = convert_to_time(err, value);
+	    break;
+	case GQL_SCALAR_UUID:
+	    code = convert_to_uuid(err, value);
+	    break;
+	default:
+	    break;
+	}
+    }
+    return code;
 }
+
+gqlValue
+gql_value_dup(agooErr err, gqlValue value) {
+    gqlValue	dup = value_create(value->type);
+
+    if (NULL == dup) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "failed to duplicate a value.");
+	return NULL;
+    }
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_BOOL:
+	dup->b = value->b;
+	break;
+    case GQL_SCALAR_INT:
+	dup->i = value->i;
+	break;
+    case GQL_SCALAR_I64:
+	dup->i64 = value->i64;
+	break;
+    case GQL_SCALAR_FLOAT:
+	dup->f = value->f;
+	break;
+    case GQL_SCALAR_STRING:
+    case GQL_SCALAR_TOKEN:
+	if (value->str.alloced) {
+	    if (NULL == (dup->str.ptr = strdup(value->str.ptr))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of length %d failed.", strlen(value->str.ptr));
+		AGOO_FREE(dup);
+		dup = NULL;
+	    }
+	} else {
+	    memcpy(dup->str.a, value->str.a, sizeof(value->str.a));
+	}
+	break;
+    case GQL_SCALAR_TIME:
+	dup->time = value->time;
+	break;
+    case GQL_SCALAR_UUID:
+	dup->uuid.hi = value->uuid.hi;
+	dup->uuid.lo = value->uuid.lo;
+	break;
+    default:
+	break;
+    }
+    return dup;
+}
+