Merge pull request #10 from chrislusf/master

merge seaweed master

README.md

@@ -49,7 +49,7 @@ Your support will be really appreciated by me and other supporters!
 
 
 - [Download Binaries for different platforms](https://github.com/chrislusf/seaweedfs/releases/latest)
-- [SeaweedFS on Slack](https://join.slack.com/t/seaweedfs/shared_invite/enQtMzI4MTMwMjU2MzA3LTc4MmVlYmFlNjBmZTgzZmJlYmI1MDE1YzkyNWYyZjkwZDFiM2RlMDdjNjVlNjdjYzc4NGFhZGIyYzEyMzJkYTA)
+- [SeaweedFS on Slack](https://join.slack.com/t/seaweedfs/shared_invite/enQtMzI4MTMwMjU2MzA3LTEyYzZmZWYzOGQ3MDJlZWMzYmI0OTE4OTJiZjJjODBmMzUxNmYwODg0YjY3MTNlMjBmZDQ1NzQ5NDJhZWI2ZmY)
 - [SeaweedFS Mailing List](https://groups.google.com/d/forum/seaweedfs)
 - [Wiki Documentation](https://github.com/chrislusf/seaweedfs/wiki)
 - [SeaweedFS Introduction Slides](https://www.slideshare.net/chrislusf/seaweedfs-introduction)

go.sum

@@ -459,7 +459,12 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
 github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+github.com/tidwall/gjson v1.3.2 h1:+7p3qQFaH3fOMXAJSrdZwGKcOO/lYdGS0HqGhPqDdTI=
+github.com/tidwall/gjson v1.3.2/go.mod h1:P256ACg0Mn+j1RXIDXoss50DeIABTYK1PULOJHhxOls=
+github.com/tidwall/match v1.0.1 h1:PnKP62LPNxHKTwvHHZZzdOAOCtsJTjo6dZLCwpKm5xc=
+github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=
 github.com/tidwall/pretty v0.0.0-20190325153808-1166b9ac2b65/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5 h1:LnC5Kc/wtumK+WB441p7ynQJzVuNRJiqddSIE3IlSEQ=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=

other/java/client/pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.github.chrislusf</groupId>
     <artifactId>seaweedfs-client</artifactId>
-    <version>1.1.6</version>
+    <version>1.2.3</version>
 
     <parent>
         <groupId>org.sonatype.oss</groupId>

other/java/client/src/main/java/seaweedfs/client/SeaweedRead.java

@@ -5,16 +5,13 @@ import org.apache.http.HttpHeaders;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpGet;
-import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.DefaultHttpClient;
 
+import java.io.Closeable;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
 
 public class SeaweedRead {
 
@@ -23,7 +20,7 @@ public class SeaweedRead {
     // returns bytesRead
     public static long read(FilerGrpcClient filerGrpcClient, List<VisibleInterval> visibleIntervals,
                             final long position, final byte[] buffer, final int bufferOffset,
-                            final int bufferLength) {
+                            final int bufferLength) throws IOException {
 
         List<ChunkView> chunkViews = viewFromVisibles(visibleIntervals, position, bufferLength);
 
@@ -58,8 +55,8 @@ public class SeaweedRead {
         return readCount;
     }
 
-    private static int readChunkView(long position, byte[] buffer, int startOffset, ChunkView chunkView, FilerProto.Locations locations) {
+    private static int readChunkView(long position, byte[] buffer, int startOffset, ChunkView chunkView, FilerProto.Locations locations) throws IOException {
-        HttpClient client = HttpClientBuilder.create().build();
+        HttpClient client = new DefaultHttpClient();
         HttpGet request = new HttpGet(
             String.format("http://%s/%s", locations.getLocations(0).getUrl(), chunkView.fileId));
 
@@ -80,10 +77,12 @@ public class SeaweedRead {
 
             return len;
 
-        } catch (IOException e) {
+        } finally {
-            e.printStackTrace();
+            if (client instanceof Closeable) {
+                Closeable t = (Closeable) client;
+                t.close();
+            }
         }
-        return 0;
     }
 
     protected static List<ChunkView> viewFromVisibles(List<VisibleInterval> visibleIntervals, long offset, long size) {

other/java/client/src/main/java/seaweedfs/client/SeaweedWrite.java

@@ -1,13 +1,14 @@
 package seaweedfs.client;
 
 import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.mime.HttpMultipartMode;
 import org.apache.http.entity.mime.MultipartEntityBuilder;
-import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.DefaultHttpClient;
-import org.apache.http.impl.client.HttpClientBuilder;
 
 import java.io.ByteArrayInputStream;
+import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
 
@@ -59,7 +60,7 @@ public class SeaweedWrite {
                                           final byte[] bytes,
                                           final long bytesOffset, final long bytesLength) throws IOException {
 
-        CloseableHttpClient client = HttpClientBuilder.create().setUserAgent("hdfs-client").build();
+        HttpClient client = new DefaultHttpClient();
 
         InputStream inputStream = new ByteArrayInputStream(bytes, (int) bytesOffset, (int) bytesLength);
 
@@ -84,7 +85,10 @@ public class SeaweedWrite {
 
             return etag;
         } finally {
-            client.close();
+            if (client instanceof Closeable) {
+                Closeable t = (Closeable) client;
+                t.close();
+            }
         }
 
     }

other/java/client/src/test/java/seaweedfs/client/SeaweedFilerTest.java

@@ -16,8 +16,8 @@ public class SeaweedFilerTest {
         filerClient.mkdirs("/new_folder", 0755);
         filerClient.touch("/new_folder/new_empty_file", 0755);
         filerClient.touch("/new_folder/new_empty_file2", 0755);
-        filerClient.rm("/new_folder/new_empty_file", false);
+        filerClient.rm("/new_folder/new_empty_file", false, true);
-        filerClient.rm("/new_folder", true);
+        filerClient.rm("/new_folder", true, true);
 
     }
 }

other/java/hdfs2/dependency-reduced-pom.xml

@@ -61,6 +61,10 @@
                     <exclude>org.apache.log4j</exclude>
                   </excludes>
                 </relocation>
+                <relocation>
+                  <pattern>org.apache.http</pattern>
+                  <shadedPattern>shaded.org.apache.http</shadedPattern>
+                </relocation>
               </relocations>
             </configuration>
           </execution>
@@ -123,7 +127,7 @@
     </snapshotRepository>
   </distributionManagement>
   <properties>
-    <seaweedfs.client.version>1.1.6</seaweedfs.client.version>
+    <seaweedfs.client.version>1.2.3</seaweedfs.client.version>
     <hadoop.version>2.9.2</hadoop.version>
   </properties>
 </project>

other/java/hdfs2/pom.xml

@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <properties>
-        <seaweedfs.client.version>1.1.6</seaweedfs.client.version>
+        <seaweedfs.client.version>1.2.3</seaweedfs.client.version>
         <hadoop.version>2.9.2</hadoop.version>
     </properties>
 
@@ -79,6 +79,10 @@
                                         <exclude>org.apache.log4j</exclude>
                                     </excludes>
                                 </relocation>
+                                <relocation>
+                                    <pattern>org.apache.http</pattern>
+                                    <shadedPattern>shaded.org.apache.http</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>

other/java/hdfs2/src/main/java/seaweed/hdfs/SeaweedFileSystemStore.java

@@ -137,7 +137,7 @@ public class SeaweedFileSystemStore {
         if (source.isRoot()) {
             return;
         }
-        LOG.warn("rename source: {} destination:{}", source, destination);
+        LOG.info("rename source: {} destination:{}", source, destination);
         FilerProto.Entry entry = lookupEntry(source);
         if (entry == null) {
             LOG.warn("rename non-existing source: {}", source);

other/java/hdfs3/dependency-reduced-pom.xml

@@ -61,6 +61,10 @@
                     <exclude>org.apache.log4j</exclude>
                   </excludes>
                 </relocation>
+                <relocation>
+                  <pattern>org.apache.http</pattern>
+                  <shadedPattern>shaded.org.apache.http</shadedPattern>
+                </relocation>
               </relocations>
             </configuration>
           </execution>
@@ -123,7 +127,7 @@
     </snapshotRepository>
   </distributionManagement>
   <properties>
-    <seaweedfs.client.version>1.1.6</seaweedfs.client.version>
+    <seaweedfs.client.version>1.2.3</seaweedfs.client.version>
     <hadoop.version>3.1.1</hadoop.version>
   </properties>
 </project>

other/java/hdfs3/pom.xml

@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <properties>
-        <seaweedfs.client.version>1.1.6</seaweedfs.client.version>
+        <seaweedfs.client.version>1.2.3</seaweedfs.client.version>
         <hadoop.version>3.1.1</hadoop.version>
     </properties>
 
@@ -79,6 +79,10 @@
                                         <exclude>org.apache.log4j</exclude>
                                     </excludes>
                                 </relocation>
+                                <relocation>
+                                    <pattern>org.apache.http</pattern>
+                                    <shadedPattern>shaded.org.apache.http</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>

other/java/hdfs3/src/main/java/seaweed/hdfs/SeaweedFileSystemStore.java

@@ -137,7 +137,7 @@ public class SeaweedFileSystemStore {
         if (source.isRoot()) {
             return;
         }
-        LOG.warn("rename source: {} destination:{}", source, destination);
+        LOG.info("rename source: {} destination:{}", source, destination);
         FilerProto.Entry entry = lookupEntry(source);
         if (entry == null) {
             LOG.warn("rename non-existing source: {}", source);

weed/pb/volume_server.proto

@@ -67,6 +67,10 @@ service VolumeServer {
     rpc VolumeEcBlobDelete (VolumeEcBlobDeleteRequest) returns (VolumeEcBlobDeleteResponse) {
     }
 
+    // query
+    rpc Query (QueryRequest) returns (stream QueriedStripe) {
+    }
+
 }
 
 //////////////////////////////////////////////////
@@ -319,3 +323,60 @@ message MemStatus {
     uint64 heap = 6;
     uint64 stack = 7;
 }
+
+message QueryRequest {
+    repeated string selections = 1;
+    repeated string from_file_ids = 2;
+    message Filter {
+        string field = 1;
+        string operand = 2;
+        string value = 3;
+    }
+    Filter filter = 3;
+
+    message InputSerialization {
+        // NONE | GZIP | BZIP2
+        string compression_type = 1;
+        message CSVInput {
+            string file_header_info = 1;  // Valid values: NONE | USE | IGNORE
+            string record_delimiter = 2;  // Default: \n
+            string field_delimiter = 3;   // Default: ,
+            string quote_charactoer = 4;  // Default: "
+            string quote_escape_character = 5; // Default: "
+            string comments = 6;          // Default: #
+            // If true, records might contain record delimiters within quote characters
+            bool   allow_quoted_record_delimiter = 7; // default False.
+        }
+        message JSONInput {
+            string type = 1;              // Valid values: DOCUMENT | LINES
+        }
+        message ParquetInput {
+        }
+
+        CSVInput csv_input = 2;
+        JSONInput json_input = 3;
+        ParquetInput parquet_input = 4;
+    }
+    InputSerialization input_serialization = 4;
+
+    message OutputSerialization {
+        message CSVOutput {
+            string quote_fields = 1;  // Valid values: ALWAYS | ASNEEDED
+            string record_delimiter = 2;  // Default: \n
+            string field_delimiter = 3;   // Default: ,
+            string quote_charactoer = 4;  // Default: "
+            string quote_escape_character = 5; // Default: "
+        }
+        message JSONOutput {
+            string record_delimiter = 1;
+        }
+
+        CSVOutput csv_output = 2;
+        JSONOutput json_output = 3;
+    }
+
+    OutputSerialization output_serialization = 5;
+}
+message QueriedStripe {
+    bytes records = 1;
+}

weed/pb/volume_server_pb/volume_server.pb.go

@@ -65,6 +65,8 @@ It has these top-level messages:
 	ReadVolumeFileStatusResponse
 	DiskStatus
 	MemStatus
+	QueryRequest
+	QueriedStripe
 */
 package volume_server_pb
 
@@ -1395,6 +1397,350 @@ func (m *MemStatus) GetStack() uint64 {
 	return 0
 }
 
+type QueryRequest struct {
+	Selections          []string                          `protobuf:"bytes,1,rep,name=selections" json:"selections,omitempty"`
+	FromFileIds         []string                          `protobuf:"bytes,2,rep,name=from_file_ids,json=fromFileIds" json:"from_file_ids,omitempty"`
+	Filter              *QueryRequest_Filter              `protobuf:"bytes,3,opt,name=filter" json:"filter,omitempty"`
+	InputSerialization  *QueryRequest_InputSerialization  `protobuf:"bytes,4,opt,name=input_serialization,json=inputSerialization" json:"input_serialization,omitempty"`
+	OutputSerialization *QueryRequest_OutputSerialization `protobuf:"bytes,5,opt,name=output_serialization,json=outputSerialization" json:"output_serialization,omitempty"`
+}
+
+func (m *QueryRequest) Reset()                    { *m = QueryRequest{} }
+func (m *QueryRequest) String() string            { return proto.CompactTextString(m) }
+func (*QueryRequest) ProtoMessage()               {}
+func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} }
+
+func (m *QueryRequest) GetSelections() []string {
+	if m != nil {
+		return m.Selections
+	}
+	return nil
+}
+
+func (m *QueryRequest) GetFromFileIds() []string {
+	if m != nil {
+		return m.FromFileIds
+	}
+	return nil
+}
+
+func (m *QueryRequest) GetFilter() *QueryRequest_Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+func (m *QueryRequest) GetInputSerialization() *QueryRequest_InputSerialization {
+	if m != nil {
+		return m.InputSerialization
+	}
+	return nil
+}
+
+func (m *QueryRequest) GetOutputSerialization() *QueryRequest_OutputSerialization {
+	if m != nil {
+		return m.OutputSerialization
+	}
+	return nil
+}
+
+type QueryRequest_Filter struct {
+	Field   string `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
+	Operand string `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
+	Value   string `protobuf:"bytes,3,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *QueryRequest_Filter) Reset()                    { *m = QueryRequest_Filter{} }
+func (m *QueryRequest_Filter) String() string            { return proto.CompactTextString(m) }
+func (*QueryRequest_Filter) ProtoMessage()               {}
+func (*QueryRequest_Filter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56, 0} }
+
+func (m *QueryRequest_Filter) GetField() string {
+	if m != nil {
+		return m.Field
+	}
+	return ""
+}
+
+func (m *QueryRequest_Filter) GetOperand() string {
+	if m != nil {
+		return m.Operand
+	}
+	return ""
+}
+
+func (m *QueryRequest_Filter) GetValue() string {
+	if m != nil {
+		return m.Value
+	}
+	return ""
+}
+
+type QueryRequest_InputSerialization struct {
+	// NONE | GZIP | BZIP2
+	CompressionType string                                        `protobuf:"bytes,1,opt,name=compression_type,json=compressionType" json:"compression_type,omitempty"`
+	CsvInput        *QueryRequest_InputSerialization_CSVInput     `protobuf:"bytes,2,opt,name=csv_input,json=csvInput" json:"csv_input,omitempty"`
+	JsonInput       *QueryRequest_InputSerialization_JSONInput    `protobuf:"bytes,3,opt,name=json_input,json=jsonInput" json:"json_input,omitempty"`
+	ParquetInput    *QueryRequest_InputSerialization_ParquetInput `protobuf:"bytes,4,opt,name=parquet_input,json=parquetInput" json:"parquet_input,omitempty"`
+}
+
+func (m *QueryRequest_InputSerialization) Reset()         { *m = QueryRequest_InputSerialization{} }
+func (m *QueryRequest_InputSerialization) String() string { return proto.CompactTextString(m) }
+func (*QueryRequest_InputSerialization) ProtoMessage()    {}
+func (*QueryRequest_InputSerialization) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 1}
+}
+
+func (m *QueryRequest_InputSerialization) GetCompressionType() string {
+	if m != nil {
+		return m.CompressionType
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization) GetCsvInput() *QueryRequest_InputSerialization_CSVInput {
+	if m != nil {
+		return m.CsvInput
+	}
+	return nil
+}
+
+func (m *QueryRequest_InputSerialization) GetJsonInput() *QueryRequest_InputSerialization_JSONInput {
+	if m != nil {
+		return m.JsonInput
+	}
+	return nil
+}
+
+func (m *QueryRequest_InputSerialization) GetParquetInput() *QueryRequest_InputSerialization_ParquetInput {
+	if m != nil {
+		return m.ParquetInput
+	}
+	return nil
+}
+
+type QueryRequest_InputSerialization_CSVInput struct {
+	FileHeaderInfo       string `protobuf:"bytes,1,opt,name=file_header_info,json=fileHeaderInfo" json:"file_header_info,omitempty"`
+	RecordDelimiter      string `protobuf:"bytes,2,opt,name=record_delimiter,json=recordDelimiter" json:"record_delimiter,omitempty"`
+	FieldDelimiter       string `protobuf:"bytes,3,opt,name=field_delimiter,json=fieldDelimiter" json:"field_delimiter,omitempty"`
+	QuoteCharactoer      string `protobuf:"bytes,4,opt,name=quote_charactoer,json=quoteCharactoer" json:"quote_charactoer,omitempty"`
+	QuoteEscapeCharacter string `protobuf:"bytes,5,opt,name=quote_escape_character,json=quoteEscapeCharacter" json:"quote_escape_character,omitempty"`
+	Comments             string `protobuf:"bytes,6,opt,name=comments" json:"comments,omitempty"`
+	// If true, records might contain record delimiters within quote characters
+	AllowQuotedRecordDelimiter bool `protobuf:"varint,7,opt,name=allow_quoted_record_delimiter,json=allowQuotedRecordDelimiter" json:"allow_quoted_record_delimiter,omitempty"`
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) Reset() {
+	*m = QueryRequest_InputSerialization_CSVInput{}
+}
+func (m *QueryRequest_InputSerialization_CSVInput) String() string { return proto.CompactTextString(m) }
+func (*QueryRequest_InputSerialization_CSVInput) ProtoMessage()    {}
+func (*QueryRequest_InputSerialization_CSVInput) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 1, 0}
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetFileHeaderInfo() string {
+	if m != nil {
+		return m.FileHeaderInfo
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetRecordDelimiter() string {
+	if m != nil {
+		return m.RecordDelimiter
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetFieldDelimiter() string {
+	if m != nil {
+		return m.FieldDelimiter
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetQuoteCharactoer() string {
+	if m != nil {
+		return m.QuoteCharactoer
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetQuoteEscapeCharacter() string {
+	if m != nil {
+		return m.QuoteEscapeCharacter
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetComments() string {
+	if m != nil {
+		return m.Comments
+	}
+	return ""
+}
+
+func (m *QueryRequest_InputSerialization_CSVInput) GetAllowQuotedRecordDelimiter() bool {
+	if m != nil {
+		return m.AllowQuotedRecordDelimiter
+	}
+	return false
+}
+
+type QueryRequest_InputSerialization_JSONInput struct {
+	Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
+}
+
+func (m *QueryRequest_InputSerialization_JSONInput) Reset() {
+	*m = QueryRequest_InputSerialization_JSONInput{}
+}
+func (m *QueryRequest_InputSerialization_JSONInput) String() string { return proto.CompactTextString(m) }
+func (*QueryRequest_InputSerialization_JSONInput) ProtoMessage()    {}
+func (*QueryRequest_InputSerialization_JSONInput) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 1, 1}
+}
+
+func (m *QueryRequest_InputSerialization_JSONInput) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+type QueryRequest_InputSerialization_ParquetInput struct {
+}
+
+func (m *QueryRequest_InputSerialization_ParquetInput) Reset() {
+	*m = QueryRequest_InputSerialization_ParquetInput{}
+}
+func (m *QueryRequest_InputSerialization_ParquetInput) String() string {
+	return proto.CompactTextString(m)
+}
+func (*QueryRequest_InputSerialization_ParquetInput) ProtoMessage() {}
+func (*QueryRequest_InputSerialization_ParquetInput) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 1, 2}
+}
+
+type QueryRequest_OutputSerialization struct {
+	CsvOutput  *QueryRequest_OutputSerialization_CSVOutput  `protobuf:"bytes,2,opt,name=csv_output,json=csvOutput" json:"csv_output,omitempty"`
+	JsonOutput *QueryRequest_OutputSerialization_JSONOutput `protobuf:"bytes,3,opt,name=json_output,json=jsonOutput" json:"json_output,omitempty"`
+}
+
+func (m *QueryRequest_OutputSerialization) Reset()         { *m = QueryRequest_OutputSerialization{} }
+func (m *QueryRequest_OutputSerialization) String() string { return proto.CompactTextString(m) }
+func (*QueryRequest_OutputSerialization) ProtoMessage()    {}
+func (*QueryRequest_OutputSerialization) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 2}
+}
+
+func (m *QueryRequest_OutputSerialization) GetCsvOutput() *QueryRequest_OutputSerialization_CSVOutput {
+	if m != nil {
+		return m.CsvOutput
+	}
+	return nil
+}
+
+func (m *QueryRequest_OutputSerialization) GetJsonOutput() *QueryRequest_OutputSerialization_JSONOutput {
+	if m != nil {
+		return m.JsonOutput
+	}
+	return nil
+}
+
+type QueryRequest_OutputSerialization_CSVOutput struct {
+	QuoteFields          string `protobuf:"bytes,1,opt,name=quote_fields,json=quoteFields" json:"quote_fields,omitempty"`
+	RecordDelimiter      string `protobuf:"bytes,2,opt,name=record_delimiter,json=recordDelimiter" json:"record_delimiter,omitempty"`
+	FieldDelimiter       string `protobuf:"bytes,3,opt,name=field_delimiter,json=fieldDelimiter" json:"field_delimiter,omitempty"`
+	QuoteCharactoer      string `protobuf:"bytes,4,opt,name=quote_charactoer,json=quoteCharactoer" json:"quote_charactoer,omitempty"`
+	QuoteEscapeCharacter string `protobuf:"bytes,5,opt,name=quote_escape_character,json=quoteEscapeCharacter" json:"quote_escape_character,omitempty"`
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) Reset() {
+	*m = QueryRequest_OutputSerialization_CSVOutput{}
+}
+func (m *QueryRequest_OutputSerialization_CSVOutput) String() string {
+	return proto.CompactTextString(m)
+}
+func (*QueryRequest_OutputSerialization_CSVOutput) ProtoMessage() {}
+func (*QueryRequest_OutputSerialization_CSVOutput) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 2, 0}
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) GetQuoteFields() string {
+	if m != nil {
+		return m.QuoteFields
+	}
+	return ""
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) GetRecordDelimiter() string {
+	if m != nil {
+		return m.RecordDelimiter
+	}
+	return ""
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) GetFieldDelimiter() string {
+	if m != nil {
+		return m.FieldDelimiter
+	}
+	return ""
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) GetQuoteCharactoer() string {
+	if m != nil {
+		return m.QuoteCharactoer
+	}
+	return ""
+}
+
+func (m *QueryRequest_OutputSerialization_CSVOutput) GetQuoteEscapeCharacter() string {
+	if m != nil {
+		return m.QuoteEscapeCharacter
+	}
+	return ""
+}
+
+type QueryRequest_OutputSerialization_JSONOutput struct {
+	RecordDelimiter string `protobuf:"bytes,1,opt,name=record_delimiter,json=recordDelimiter" json:"record_delimiter,omitempty"`
+}
+
+func (m *QueryRequest_OutputSerialization_JSONOutput) Reset() {
+	*m = QueryRequest_OutputSerialization_JSONOutput{}
+}
+func (m *QueryRequest_OutputSerialization_JSONOutput) String() string {
+	return proto.CompactTextString(m)
+}
+func (*QueryRequest_OutputSerialization_JSONOutput) ProtoMessage() {}
+func (*QueryRequest_OutputSerialization_JSONOutput) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{56, 2, 1}
+}
+
+func (m *QueryRequest_OutputSerialization_JSONOutput) GetRecordDelimiter() string {
+	if m != nil {
+		return m.RecordDelimiter
+	}
+	return ""
+}
+
+type QueriedStripe struct {
+	Records []byte `protobuf:"bytes,1,opt,name=records,proto3" json:"records,omitempty"`
+}
+
+func (m *QueriedStripe) Reset()                    { *m = QueriedStripe{} }
+func (m *QueriedStripe) String() string            { return proto.CompactTextString(m) }
+func (*QueriedStripe) ProtoMessage()               {}
+func (*QueriedStripe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} }
+
+func (m *QueriedStripe) GetRecords() []byte {
+	if m != nil {
+		return m.Records
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*BatchDeleteRequest)(nil), "volume_server_pb.BatchDeleteRequest")
 	proto.RegisterType((*BatchDeleteResponse)(nil), "volume_server_pb.BatchDeleteResponse")
@@ -1452,6 +1798,16 @@ func init() {
 	proto.RegisterType((*ReadVolumeFileStatusResponse)(nil), "volume_server_pb.ReadVolumeFileStatusResponse")
 	proto.RegisterType((*DiskStatus)(nil), "volume_server_pb.DiskStatus")
 	proto.RegisterType((*MemStatus)(nil), "volume_server_pb.MemStatus")
+	proto.RegisterType((*QueryRequest)(nil), "volume_server_pb.QueryRequest")
+	proto.RegisterType((*QueryRequest_Filter)(nil), "volume_server_pb.QueryRequest.Filter")
+	proto.RegisterType((*QueryRequest_InputSerialization)(nil), "volume_server_pb.QueryRequest.InputSerialization")
+	proto.RegisterType((*QueryRequest_InputSerialization_CSVInput)(nil), "volume_server_pb.QueryRequest.InputSerialization.CSVInput")
+	proto.RegisterType((*QueryRequest_InputSerialization_JSONInput)(nil), "volume_server_pb.QueryRequest.InputSerialization.JSONInput")
+	proto.RegisterType((*QueryRequest_InputSerialization_ParquetInput)(nil), "volume_server_pb.QueryRequest.InputSerialization.ParquetInput")
+	proto.RegisterType((*QueryRequest_OutputSerialization)(nil), "volume_server_pb.QueryRequest.OutputSerialization")
+	proto.RegisterType((*QueryRequest_OutputSerialization_CSVOutput)(nil), "volume_server_pb.QueryRequest.OutputSerialization.CSVOutput")
+	proto.RegisterType((*QueryRequest_OutputSerialization_JSONOutput)(nil), "volume_server_pb.QueryRequest.OutputSerialization.JSONOutput")
+	proto.RegisterType((*QueriedStripe)(nil), "volume_server_pb.QueriedStripe")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1494,6 +1850,8 @@ type VolumeServerClient interface {
 	VolumeEcShardsUnmount(ctx context.Context, in *VolumeEcShardsUnmountRequest, opts ...grpc.CallOption) (*VolumeEcShardsUnmountResponse, error)
 	VolumeEcShardRead(ctx context.Context, in *VolumeEcShardReadRequest, opts ...grpc.CallOption) (VolumeServer_VolumeEcShardReadClient, error)
 	VolumeEcBlobDelete(ctx context.Context, in *VolumeEcBlobDeleteRequest, opts ...grpc.CallOption) (*VolumeEcBlobDeleteResponse, error)
+	// query
+	Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error)
 }
 
 type volumeServerClient struct {
@@ -1830,6 +2188,38 @@ func (c *volumeServerClient) VolumeEcBlobDelete(ctx context.Context, in *VolumeE
 	return out, nil
 }
 
+func (c *volumeServerClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[4], c.cc, "/volume_server_pb.VolumeServer/Query", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volumeServerQueryClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolumeServer_QueryClient interface {
+	Recv() (*QueriedStripe, error)
+	grpc.ClientStream
+}
+
+type volumeServerQueryClient struct {
+	grpc.ClientStream
+}
+
+func (x *volumeServerQueryClient) Recv() (*QueriedStripe, error) {
+	m := new(QueriedStripe)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for VolumeServer service
 
 type VolumeServerServer interface {
@@ -1862,6 +2252,8 @@ type VolumeServerServer interface {
 	VolumeEcShardsUnmount(context.Context, *VolumeEcShardsUnmountRequest) (*VolumeEcShardsUnmountResponse, error)
 	VolumeEcShardRead(*VolumeEcShardReadRequest, VolumeServer_VolumeEcShardReadServer) error
 	VolumeEcBlobDelete(context.Context, *VolumeEcBlobDeleteRequest) (*VolumeEcBlobDeleteResponse, error)
+	// query
+	Query(*QueryRequest, VolumeServer_QueryServer) error
 }
 
 func RegisterVolumeServerServer(s *grpc.Server, srv VolumeServerServer) {
@@ -2349,6 +2741,27 @@ func _VolumeServer_VolumeEcBlobDelete_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _VolumeServer_Query_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(QueryRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolumeServerServer).Query(m, &volumeServerQueryServer{stream})
+}
+
+type VolumeServer_QueryServer interface {
+	Send(*QueriedStripe) error
+	grpc.ServerStream
+}
+
+type volumeServerQueryServer struct {
+	grpc.ServerStream
+}
+
+func (x *volumeServerQueryServer) Send(m *QueriedStripe) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "volume_server_pb.VolumeServer",
 	HandlerType: (*VolumeServerServer)(nil),
@@ -2463,6 +2876,11 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			Handler:       _VolumeServer_VolumeEcShardRead_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "Query",
+			Handler:       _VolumeServer_Query_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "volume_server.proto",
 }
@@ -2470,126 +2888,160 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1924 bytes of a gzipped FileDescriptorProto
+	// 2473 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x19, 0xcb, 0x72, 0xdc, 0xc6,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x3a, 0x4f, 0x77, 0x1c, 0x47,
-	0x91, 0xd0, 0x2e, 0xb9, 0xbb, 0xbd, 0x4b, 0x89, 0x1c, 0x52, 0xe4, 0x0a, 0x14, 0x29, 0x1a, 0x76,
+	0xf1, 0x5a, 0xef, 0x4a, 0xda, 0xad, 0x5d, 0x59, 0x72, 0x4b, 0xb1, 0x36, 0x63, 0x4b, 0x56, 0x26,
-	0x6c, 0x8a, 0xb2, 0x49, 0x45, 0xae, 0x24, 0x4e, 0x72, 0x48, 0x44, 0x8a, 0x49, 0x54, 0x8e, 0xe9,
+	0x7f, 0x2c, 0xdb, 0x89, 0xec, 0x28, 0xbf, 0x1f, 0x09, 0x09, 0x01, 0x6c, 0xd9, 0x06, 0x93, 0x44,
-	0x2a, 0x50, 0x56, 0x39, 0x65, 0x57, 0xa1, 0x86, 0xc0, 0x50, 0x44, 0x11, 0x0b, 0x40, 0x98, 0x01,
+	0x26, 0x23, 0xc7, 0x04, 0x9c, 0xc7, 0xbc, 0xd6, 0x4c, 0xcb, 0x1a, 0x34, 0x3b, 0x3d, 0x9e, 0xee,
-	0xa5, 0x55, 0x25, 0x27, 0xe5, 0x9a, 0x0f, 0xc8, 0x39, 0xb7, 0x1c, 0x72, 0xcd, 0x07, 0xe4, 0x17,
+	0x91, 0xbd, 0x7e, 0x70, 0x0a, 0x57, 0x3e, 0x00, 0x67, 0x4e, 0x70, 0xe0, 0xca, 0x07, 0xe0, 0xc2,
-	0x72, 0xcb, 0x37, 0xe4, 0x0b, 0x72, 0x49, 0xcd, 0x03, 0x58, 0x3c, 0x77, 0xc1, 0x90, 0x55, 0xb9,
+	0x07, 0x80, 0x4f, 0xc0, 0x99, 0x03, 0x37, 0xde, 0xe3, 0xc2, 0xeb, 0x3f, 0x33, 0x3b, 0x7f, 0xb5,
-	0x61, 0x7b, 0xfa, 0x3d, 0xdd, 0x3d, 0xdd, 0xbd, 0xb0, 0x72, 0x19, 0x78, 0xf1, 0x88, 0x58, 0x94,
+	0xa3, 0xd8, 0xef, 0xf1, 0xb8, 0xf5, 0x54, 0xd7, 0x9f, 0xae, 0xea, 0xaa, 0xea, 0xea, 0xea, 0x81,
-	0x44, 0x97, 0x24, 0xda, 0x0b, 0xa3, 0x80, 0x05, 0x68, 0x29, 0x07, 0xb4, 0xc2, 0x53, 0x63, 0x1f,
+	0xe5, 0x63, 0xea, 0xc7, 0x23, 0x62, 0x33, 0x12, 0x1d, 0x93, 0x68, 0x2b, 0x8c, 0x28, 0xa7, 0x68,
-	0xd0, 0x01, 0x66, 0xf6, 0xf9, 0x33, 0xe2, 0x11, 0x46, 0x4c, 0xf2, 0x3a, 0x26, 0x94, 0xa1, 0x7b,
+	0x29, 0x07, 0xb4, 0xc3, 0x7d, 0xf3, 0x3a, 0xa0, 0x5b, 0x98, 0x3b, 0x87, 0xb7, 0x89, 0x4f, 0x38,
-	0xd0, 0x3d, 0x73, 0x3d, 0x62, 0xb9, 0x0e, 0x1d, 0x6a, 0xdb, 0xad, 0x9d, 0x9e, 0xd9, 0xe1, 0xbf,
+	0xb1, 0xc8, 0x93, 0x98, 0x30, 0x8e, 0x5e, 0x85, 0xee, 0x81, 0xe7, 0x13, 0xdb, 0x73, 0xd9, 0xb0,
-	0x9f, 0x3b, 0xd4, 0xf8, 0x1a, 0x56, 0x72, 0x04, 0x34, 0x0c, 0x7c, 0x4a, 0xd0, 0x17, 0xd0, 0x89,
+	0xb5, 0xd1, 0xde, 0xec, 0x59, 0xf3, 0xe2, 0xfb, 0x9e, 0xcb, 0xcc, 0xfb, 0xb0, 0x9c, 0x23, 0x60,
-	0x08, 0x8d, 0x3d, 0x26, 0x09, 0xfa, 0x4f, 0xb6, 0xf6, 0x8a, 0xb2, 0xf6, 0x52, 0x92, 0xd8, 0x63,
+	0x21, 0x0d, 0x18, 0x41, 0x1f, 0xc0, 0x7c, 0x44, 0x58, 0xec, 0x73, 0x45, 0xd0, 0xdf, 0x5e, 0xdf,
-	0x66, 0x82, 0x6e, 0xbc, 0xd7, 0x60, 0x90, 0x3d, 0x41, 0xeb, 0xd0, 0x51, 0xc2, 0x87, 0xda, 0xb6,
+	0x2a, 0xca, 0xda, 0x4a, 0x49, 0x62, 0x9f, 0x5b, 0x09, 0xba, 0xf9, 0x75, 0x0b, 0x06, 0xd9, 0x19,
-	0xb6, 0xd3, 0x33, 0x17, 0xa4, 0x6c, 0xb4, 0x06, 0x0b, 0x94, 0x61, 0x16, 0xd3, 0xe1, 0xad, 0x6d,
+	0xb4, 0x0a, 0xf3, 0x5a, 0xf8, 0xb0, 0xb5, 0xd1, 0xda, 0xec, 0x59, 0x73, 0x4a, 0x36, 0x3a, 0x0f,
-	0x6d, 0x67, 0xde, 0x54, 0xbf, 0xd0, 0x2a, 0xcc, 0x93, 0x28, 0x0a, 0xa2, 0x61, 0x4b, 0xa0, 0xcb,
+	0x73, 0x8c, 0x63, 0x1e, 0xb3, 0xe1, 0x99, 0x8d, 0xd6, 0xe6, 0xac, 0xa5, 0xbf, 0xd0, 0x0a, 0xcc,
-	0x1f, 0x08, 0x41, 0x9b, 0xba, 0xef, 0xc8, 0xb0, 0xbd, 0xad, 0xed, 0x2c, 0x9a, 0xe2, 0x1b, 0x0d,
+	0x92, 0x28, 0xa2, 0xd1, 0xb0, 0x2d, 0xd1, 0xd5, 0x07, 0x42, 0xd0, 0x61, 0xde, 0x73, 0x32, 0xec,
-	0xa1, 0x73, 0x49, 0x22, 0xea, 0x06, 0xfe, 0x70, 0x5e, 0x80, 0x93, 0x9f, 0x46, 0x07, 0xe6, 0x8f,
+	0x6c, 0xb4, 0x36, 0x17, 0x2c, 0x39, 0x46, 0x43, 0x98, 0x3f, 0x26, 0x11, 0xf3, 0x68, 0x30, 0x9c,
-	0x46, 0x21, 0x1b, 0x1b, 0x3f, 0x81, 0xe1, 0x4b, 0x6c, 0xc7, 0xf1, 0xe8, 0xa5, 0x50, 0xff, 0xf0,
+	0x95, 0xe0, 0xe4, 0xd3, 0x9c, 0x87, 0xd9, 0x3b, 0xa3, 0x90, 0x8f, 0xcd, 0xf7, 0x61, 0xf8, 0x10,
-	0x9c, 0xd8, 0x17, 0x89, 0x5b, 0x36, 0xa0, 0xa7, 0x8c, 0x52, 0xba, 0x2d, 0x9a, 0x5d, 0x09, 0x78,
+	0x3b, 0x71, 0x3c, 0x7a, 0x28, 0x97, 0xbf, 0x73, 0x48, 0x9c, 0xa3, 0xc4, 0x2c, 0x17, 0xa0, 0xa7,
-	0xee, 0x18, 0xbf, 0x84, 0x7b, 0x15, 0x84, 0xca, 0x3d, 0x1f, 0xc2, 0xe2, 0x2b, 0x1c, 0x9d, 0xe2,
+	0x95, 0xd2, 0x6b, 0x5b, 0xb0, 0xba, 0x0a, 0x70, 0xcf, 0x35, 0xbf, 0x0f, 0xaf, 0x56, 0x10, 0x6a,
-	0x57, 0xc4, 0x8a, 0x30, 0x73, 0x03, 0x41, 0xad, 0x99, 0x03, 0x05, 0x34, 0x39, 0xcc, 0xf8, 0x0e,
+	0xf3, 0xbc, 0x0e, 0x0b, 0x8f, 0x71, 0xb4, 0x8f, 0x1f, 0x13, 0x3b, 0xc2, 0xdc, 0xa3, 0x92, 0xba,
-	0xf4, 0x1c, 0x87, 0x60, 0x14, 0x62, 0x9b, 0x35, 0x11, 0x8e, 0xb6, 0xa1, 0x1f, 0x46, 0x04, 0x7b,
+	0x65, 0x0d, 0x34, 0xd0, 0x12, 0x30, 0xf3, 0x11, 0x18, 0x39, 0x0e, 0x74, 0x14, 0x62, 0x87, 0x37,
-	0x5e, 0x60, 0x63, 0x46, 0x84, 0x7f, 0x5a, 0x66, 0x16, 0x64, 0x6c, 0xc2, 0x46, 0x25, 0x73, 0xa9,
+	0x11, 0x8e, 0x36, 0xa0, 0x1f, 0x46, 0x04, 0xfb, 0x3e, 0x75, 0x30, 0x27, 0xd2, 0x3e, 0x6d, 0x2b,
-	0xa0, 0xf1, 0x45, 0x41, 0xfb, 0x60, 0x34, 0x72, 0x1b, 0x89, 0x36, 0xee, 0x97, 0xb4, 0x16, 0x94,
+	0x0b, 0x32, 0xd7, 0xe0, 0x42, 0x25, 0x73, 0xb5, 0x40, 0xf3, 0x83, 0xc2, 0xea, 0xe9, 0x68, 0xe4,
-	0x8a, 0xef, 0x4f, 0x0b, 0xa7, 0x1e, 0xc1, 0x7e, 0x1c, 0x36, 0x62, 0x5c, 0xd4, 0x38, 0x21, 0x4d,
+	0x35, 0x12, 0x6d, 0x5e, 0x2c, 0xad, 0x5a, 0x52, 0x6a, 0xbe, 0xdf, 0x2e, 0xcc, 0xfa, 0x04, 0x07,
-	0x39, 0xaf, 0xcb, 0xb0, 0x39, 0x0c, 0x3c, 0x8f, 0xd8, 0xcc, 0x0d, 0xfc, 0x84, 0xed, 0x16, 0x80,
+	0x71, 0xd8, 0x88, 0x71, 0x71, 0xc5, 0x09, 0x69, 0xca, 0x79, 0x55, 0xb9, 0xcd, 0x0e, 0xf5, 0x7d,
-	0x9d, 0x02, 0x55, 0x10, 0x65, 0x20, 0x86, 0x0e, 0xc3, 0x32, 0xa9, 0x62, 0xfb, 0x57, 0x0d, 0xee,
+	0xe2, 0x70, 0x8f, 0x06, 0x09, 0xdb, 0x75, 0x00, 0x27, 0x05, 0x6a, 0x27, 0xca, 0x40, 0x4c, 0x03,
-	0x3e, 0x55, 0x4e, 0x93, 0x82, 0x1b, 0x5d, 0x40, 0x5e, 0xe4, 0xad, 0xa2, 0xc8, 0xe2, 0x05, 0xb5,
+	0x86, 0x65, 0x52, 0xcd, 0xf6, 0x0f, 0x2d, 0x78, 0xe5, 0xa6, 0x36, 0x9a, 0x12, 0xdc, 0x68, 0x03,
-	0x4a, 0x17, 0xc4, 0x31, 0x22, 0x12, 0x7a, 0xae, 0x8d, 0x05, 0x8b, 0xb6, 0x60, 0x91, 0x05, 0xa1,
+	0xf2, 0x22, 0xcf, 0x14, 0x45, 0x16, 0x37, 0xa8, 0x5d, 0xda, 0x20, 0x81, 0x11, 0x91, 0xd0, 0xf7,
-	0x25, 0x68, 0x31, 0xe6, 0x89, 0xc8, 0xed, 0x99, 0xfc, 0xd3, 0x18, 0xc2, 0x5a, 0x51, 0x57, 0x65,
+	0x1c, 0x2c, 0x59, 0x74, 0x24, 0x8b, 0x2c, 0x08, 0x2d, 0x41, 0x9b, 0x73, 0x5f, 0x7a, 0x6e, 0xcf,
-	0xc6, 0x8f, 0x61, 0x5d, 0x42, 0x4e, 0xc6, 0xbe, 0x7d, 0x22, 0xf2, 0xa4, 0x91, 0xd3, 0xff, 0xa3,
+	0x12, 0x43, 0x73, 0x08, 0xe7, 0x8b, 0x6b, 0xd5, 0x6a, 0x7c, 0x0b, 0x56, 0x15, 0x64, 0x6f, 0x1c,
-	0xc1, 0xb0, 0x4c, 0xa8, 0xa2, 0xf8, 0xba, 0x1e, 0xb8, 0xaa, 0x7d, 0xe8, 0x01, 0xf4, 0x19, 0x76,
+	0x38, 0x7b, 0x32, 0x4e, 0x1a, 0x19, 0xfd, 0xdf, 0x2d, 0x18, 0x96, 0x09, 0xb5, 0x17, 0xbf, 0xa8,
-	0x3d, 0x2b, 0x38, 0x3b, 0xa3, 0x84, 0x0d, 0x17, 0xb6, 0xb5, 0x9d, 0xb6, 0x09, 0x1c, 0xf4, 0xb5,
+	0x05, 0x4e, 0xab, 0x1f, 0xba, 0x04, 0x7d, 0x8e, 0x3d, 0xdf, 0xa6, 0x07, 0x07, 0x8c, 0xf0, 0xe1,
-	0x80, 0xa0, 0x87, 0xb0, 0x64, 0xcb, 0x48, 0xb6, 0x22, 0x72, 0xe9, 0x8a, 0xcc, 0xee, 0x08, 0xc5,
+	0xdc, 0x46, 0x6b, 0xb3, 0x63, 0x81, 0x00, 0xdd, 0x97, 0x10, 0x74, 0x05, 0x96, 0x1c, 0xe5, 0xc9,
-	0xee, 0xd8, 0x49, 0x84, 0x4b, 0x30, 0x32, 0x60, 0xd1, 0x75, 0xde, 0x5a, 0xa2, 0xb4, 0x88, 0xc2,
+	0x76, 0x44, 0x8e, 0x3d, 0x19, 0xd9, 0xf3, 0x72, 0x61, 0x8b, 0x4e, 0xe2, 0xe1, 0x0a, 0x8c, 0x4c,
-	0xd0, 0x15, 0xdc, 0xfa, 0xae, 0xf3, 0xf6, 0x57, 0xae, 0x47, 0x4e, 0xdc, 0x77, 0xc4, 0x78, 0x09,
+	0x58, 0xf0, 0xdc, 0x67, 0xb6, 0x4c, 0x2d, 0x32, 0x31, 0x74, 0x25, 0xb7, 0xbe, 0xe7, 0x3e, 0xbb,
-	0xf7, 0xa5, 0xf1, 0xcf, 0x7d, 0x3b, 0x22, 0x23, 0xe2, 0x33, 0xec, 0x1d, 0x06, 0xe1, 0xb8, 0x51,
+	0xeb, 0xf9, 0x64, 0xcf, 0x7b, 0x4e, 0xcc, 0x87, 0x70, 0x51, 0x29, 0x7f, 0x2f, 0x70, 0x22, 0x32,
-	0x08, 0xdc, 0x83, 0x2e, 0x75, 0x7d, 0x9b, 0x58, 0xbe, 0x2c, 0x50, 0x6d, 0xb3, 0x23, 0x7e, 0x1f,
+	0x22, 0x01, 0xc7, 0xfe, 0x0e, 0x0d, 0xc7, 0x8d, 0x5c, 0xe0, 0x55, 0xe8, 0x32, 0x2f, 0x70, 0x88,
-	0x53, 0xe3, 0x00, 0x36, 0x6b, 0xf8, 0x2a, 0xcf, 0x7e, 0x00, 0x03, 0xa1, 0x98, 0x1d, 0xf8, 0x8c,
+	0x1d, 0xa8, 0x04, 0xd5, 0xb1, 0xe6, 0xe5, 0xf7, 0x2e, 0x33, 0x6f, 0xc1, 0x5a, 0x0d, 0x5f, 0x6d,
-	0xf8, 0x4c, 0xf0, 0x1e, 0x98, 0x7d, 0x0e, 0x3b, 0x94, 0x20, 0xe3, 0x87, 0x80, 0x24, 0x8f, 0xaf,
+	0xd9, 0xd7, 0x60, 0x20, 0x17, 0xe6, 0xd0, 0x80, 0x93, 0x80, 0x4b, 0xde, 0x03, 0xab, 0x2f, 0x60,
-	0x82, 0xd8, 0x6f, 0x96, 0x9a, 0x77, 0x61, 0x25, 0x47, 0xa2, 0x62, 0xe3, 0x73, 0x58, 0x95, 0xe0,
+	0x3b, 0x0a, 0x64, 0xbe, 0x0b, 0x48, 0xf1, 0xf8, 0x8c, 0xc6, 0x41, 0xb3, 0xd0, 0x7c, 0x05, 0x96,
-	0x6f, 0xfc, 0x51, 0x63, 0x5e, 0xeb, 0x70, 0xb7, 0x40, 0xa4, 0xb8, 0x3d, 0x49, 0x84, 0xe4, 0x9f,
+	0x73, 0x24, 0xda, 0x37, 0xde, 0x83, 0x15, 0x05, 0xfe, 0x22, 0x18, 0x35, 0xe6, 0xb5, 0x0a, 0xaf,
-	0x90, 0xa9, 0xcc, 0xd6, 0x12, 0x0d, 0xf2, 0xaf, 0x88, 0xa8, 0x42, 0x52, 0x61, 0x1c, 0x5d, 0x98,
+	0x14, 0x88, 0x34, 0xb7, 0xed, 0x44, 0x48, 0xfe, 0x08, 0x39, 0x91, 0xd9, 0xf9, 0x64, 0x05, 0xf9,
-	0x04, 0x3b, 0x81, 0xef, 0x8d, 0x1b, 0x57, 0xa1, 0x0a, 0x4a, 0xc5, 0xf7, 0x6f, 0x1a, 0x2c, 0x27,
+	0x53, 0x44, 0x66, 0x21, 0xb5, 0x60, 0x1c, 0x1d, 0x59, 0x04, 0xbb, 0x34, 0xf0, 0xc7, 0x8d, 0xb3,
-	0xe5, 0xa9, 0xe1, 0x6d, 0x5e, 0x31, 0x9c, 0x5b, 0xb5, 0xe1, 0xdc, 0x9e, 0x84, 0xf3, 0x0e, 0x2c,
+	0x50, 0x05, 0xa5, 0xe6, 0xfb, 0xc7, 0x16, 0x9c, 0x4b, 0xd2, 0x53, 0xc3, 0xdd, 0x3c, 0xa5, 0x3b,
-	0xd1, 0x20, 0x8e, 0x6c, 0x62, 0x39, 0x98, 0x61, 0xcb, 0x0f, 0x1c, 0xa2, 0xa2, 0xfd, 0xb6, 0x84,
+	0xb7, 0x6b, 0xdd, 0xb9, 0x33, 0x71, 0xe7, 0x4d, 0x58, 0x62, 0x34, 0x8e, 0x1c, 0x62, 0xbb, 0x98,
-	0x3f, 0xc3, 0x0c, 0x1f, 0x07, 0x0e, 0x31, 0x7e, 0x91, 0x5c, 0x76, 0x2e, 0x4a, 0x1e, 0xc2, 0xb2,
+	0x63, 0x3b, 0xa0, 0x2e, 0xd1, 0xde, 0x7e, 0x56, 0xc1, 0x6f, 0x63, 0x8e, 0x77, 0xa9, 0x4b, 0xcc,
-	0x87, 0x29, 0xb3, 0x70, 0x18, 0x12, 0xdf, 0xb1, 0x30, 0xe3, 0xa1, 0xa6, 0x89, 0x50, 0xbb, 0xcd,
+	0xef, 0x25, 0x9b, 0x9d, 0xf3, 0x92, 0x2b, 0x70, 0xce, 0xc7, 0x8c, 0xdb, 0x38, 0x0c, 0x49, 0xe0,
-	0x0f, 0x9e, 0x0a, 0xf8, 0x53, 0x76, 0x4c, 0x8d, 0x7f, 0x6a, 0x70, 0x87, 0xd3, 0xf2, 0xd0, 0x6e,
+	0xda, 0x98, 0x0b, 0x57, 0x6b, 0x49, 0x57, 0x3b, 0x2b, 0x26, 0x6e, 0x4a, 0xf8, 0x4d, 0xbe, 0xcb,
-	0x64, 0xef, 0x12, 0xb4, 0xc8, 0x5b, 0xa6, 0x0c, 0xe5, 0x9f, 0x68, 0x1f, 0x56, 0x54, 0x0e, 0xb9,
+	0xcc, 0xbf, 0xb6, 0x60, 0x51, 0xd0, 0x0a, 0xd7, 0x6e, 0xa4, 0xef, 0x12, 0xb4, 0xc9, 0x33, 0xae,
-	0x81, 0x3f, 0x49, 0xaf, 0x96, 0x20, 0x44, 0x93, 0xa3, 0x34, 0xc3, 0x1e, 0x40, 0x9f, 0xb2, 0x20,
+	0x15, 0x15, 0x43, 0x74, 0x1d, 0x96, 0x75, 0x0c, 0x79, 0x34, 0x98, 0x84, 0x57, 0x5b, 0x12, 0xa2,
-	0x4c, 0xb2, 0xb5, 0x2d, 0xb3, 0x95, 0x83, 0x54, 0xb6, 0xe6, 0x7d, 0x3a, 0x5f, 0xe1, 0xd3, 0x81,
+	0xc9, 0x54, 0x1a, 0x61, 0x97, 0xa0, 0xcf, 0x38, 0x0d, 0x93, 0x68, 0xed, 0xa8, 0x68, 0x15, 0x20,
-	0x4b, 0x2d, 0x62, 0x5b, 0x52, 0x2b, 0x91, 0xef, 0x5d, 0x13, 0x5c, 0x7a, 0x64, 0x4b, 0x6f, 0x18,
+	0x1d, 0xad, 0x79, 0x9b, 0xce, 0x56, 0xd8, 0x74, 0xe0, 0x31, 0x9b, 0x38, 0xb6, 0x5a, 0x95, 0x8c,
-	0x3f, 0x82, 0xa5, 0x89, 0x55, 0xcd, 0x73, 0xe7, 0xbd, 0x96, 0x94, 0xc3, 0x17, 0xd8, 0xf5, 0x4e,
+	0xf7, 0xae, 0x05, 0x1e, 0xbb, 0xe3, 0x28, 0x6b, 0x98, 0xff, 0x0f, 0x4b, 0x13, 0xad, 0x9a, 0xc7,
-	0x88, 0xef, 0x90, 0xe8, 0x9a, 0x39, 0x8d, 0x1e, 0xc3, 0xaa, 0xeb, 0x78, 0xc4, 0x62, 0xee, 0x88,
+	0xce, 0xd7, 0xad, 0x24, 0x1d, 0x3e, 0xc0, 0x9e, 0xbf, 0x47, 0x02, 0x97, 0x44, 0x2f, 0x18, 0xd3,
-	0x04, 0x31, 0xb3, 0x28, 0xb1, 0x03, 0xdf, 0xa1, 0x89, 0x7f, 0xf8, 0xd9, 0x0b, 0x79, 0x74, 0x22,
+	0xe8, 0x06, 0xac, 0x78, 0xae, 0x4f, 0x6c, 0xee, 0x8d, 0x08, 0x8d, 0xb9, 0xcd, 0x88, 0x43, 0x03,
-	0x4f, 0x8c, 0x3f, 0xa6, 0xb5, 0x35, 0xab, 0xc5, 0xa4, 0x43, 0xf0, 0x09, 0xe1, 0x0c, 0xcf, 0x09,
+	0x97, 0x25, 0xf6, 0x11, 0x73, 0x0f, 0xd4, 0xd4, 0x9e, 0x9a, 0x31, 0x7f, 0x9d, 0xe6, 0xd6, 0xec,
-	0x76, 0x48, 0xa4, 0xcc, 0x18, 0x48, 0xe0, 0x6f, 0x04, 0x8c, 0x7b, 0x58, 0x21, 0x9d, 0x06, 0xce,
+	0x2a, 0x26, 0x15, 0x42, 0x40, 0x88, 0x60, 0x78, 0x48, 0xb0, 0x4b, 0x22, 0xad, 0xc6, 0x40, 0x01,
-	0x58, 0x68, 0x34, 0x30, 0x41, 0x82, 0x0e, 0x02, 0x67, 0x2c, 0x8a, 0x1c, 0xb5, 0x44, 0x90, 0xd8,
+	0x7f, 0x28, 0x61, 0xc2, 0xc2, 0x1a, 0x69, 0x9f, 0xba, 0x63, 0xb9, 0xa2, 0x81, 0x05, 0x0a, 0x74,
-	0xe7, 0xb1, 0x7f, 0x21, 0xb4, 0xe9, 0x9a, 0x7d, 0x97, 0xfe, 0x16, 0x53, 0x76, 0xc8, 0x41, 0xc6,
+	0x8b, 0xba, 0x63, 0x99, 0xe4, 0x98, 0x2d, 0x9d, 0xc4, 0x39, 0x8c, 0x83, 0x23, 0xb9, 0x9a, 0xae,
-	0xdf, 0xb5, 0x24, 0xcb, 0xb8, 0x1a, 0x26, 0xb1, 0x89, 0x7b, 0xf9, 0x7f, 0x70, 0x07, 0xa7, 0x50,
+	0xd5, 0xf7, 0xd8, 0xa7, 0x98, 0xf1, 0x1d, 0x01, 0x32, 0xff, 0xd4, 0x4a, 0xa2, 0x4c, 0x2c, 0xc3,
-	0xd9, 0x90, 0xeb, 0x14, 0x55, 0xc2, 0x20, 0x79, 0xa6, 0xde, 0x22, 0x71, 0x32, 0x49, 0xf2, 0xbc,
+	0x22, 0x0e, 0xf1, 0x8e, 0xff, 0x0b, 0xe6, 0x10, 0x14, 0x3a, 0x1a, 0x72, 0x95, 0xa2, 0x0e, 0x18,
-	0xe2, 0x2a, 0xc9, 0xbf, 0x4f, 0x8a, 0xec, 0x91, 0x7d, 0x72, 0x8e, 0x23, 0x87, 0xfe, 0x9a, 0xf8,
+	0xa4, 0xe6, 0xf4, 0x59, 0x24, 0x67, 0x26, 0x41, 0x9e, 0x5f, 0xb8, 0x0e, 0xf2, 0xaf, 0x92, 0x24,
-	0x24, 0xc2, 0xec, 0x46, 0x1e, 0x70, 0x63, 0x1b, 0xb6, 0xea, 0xb8, 0x2b, 0xf9, 0xdf, 0x25, 0x8f,
+	0x7b, 0xc7, 0xd9, 0x3b, 0xc4, 0x91, 0xcb, 0x7e, 0x40, 0x02, 0x12, 0x61, 0xfe, 0x52, 0x0e, 0x70,
-	0x47, 0x82, 0x61, 0x92, 0xd3, 0xd8, 0xf5, 0x9c, 0x1b, 0x11, 0xff, 0x65, 0xd1, 0xb8, 0x94, 0xb9,
+	0x73, 0x03, 0xd6, 0xeb, 0xb8, 0x6b, 0xf9, 0x8f, 0x92, 0xc3, 0x23, 0xc1, 0xb0, 0xc8, 0x7e, 0xec,
-	0x8a, 0x9f, 0x5d, 0x58, 0x8e, 0x04, 0x88, 0x59, 0x94, 0x23, 0xa4, 0xbd, 0xfb, 0xa2, 0x79, 0x47,
+	0xf9, 0xee, 0x4b, 0x11, 0xff, 0x49, 0x51, 0xb9, 0x94, 0xb9, 0xf6, 0x9f, 0xab, 0x70, 0x2e, 0x92,
-	0x1d, 0x08, 0x42, 0xde, 0xc3, 0xff, 0x23, 0x8d, 0x80, 0x84, 0xdb, 0x8d, 0x95, 0xc5, 0x0d, 0xe8,
+	0x20, 0x6e, 0x33, 0x81, 0x90, 0xd6, 0xee, 0x0b, 0xd6, 0xa2, 0x9e, 0x90, 0x84, 0xa2, 0x86, 0xff,
-	0x4d, 0xc4, 0xb7, 0x84, 0xf8, 0x2e, 0x55, 0x72, 0x79, 0x74, 0xda, 0x41, 0x38, 0xb6, 0x88, 0x2d,
+	0x73, 0xea, 0x01, 0x09, 0xb7, 0x97, 0x96, 0x16, 0x2f, 0x40, 0x6f, 0x22, 0xbe, 0x2d, 0xc5, 0x77,
-	0xdf, 0x61, 0x71, 0xd5, 0x5d, 0xb3, 0xcf, 0x81, 0x47, 0xb6, 0x78, 0x86, 0xaf, 0x50, 0x23, 0xd3,
+	0x99, 0x96, 0x2b, 0xbc, 0xd3, 0xa1, 0xe1, 0xd8, 0x26, 0x8e, 0x3a, 0x87, 0xe5, 0x56, 0x77, 0xad,
-	0x68, 0xc8, 0x1b, 0xa1, 0x6e, 0xe3, 0x0d, 0x6c, 0xe4, 0x4f, 0x9b, 0x3f, 0x4f, 0xd7, 0x32, 0xd2,
+	0xbe, 0x00, 0xde, 0x71, 0xe4, 0x31, 0x7c, 0x8a, 0x1c, 0x99, 0x7a, 0x43, 0x5e, 0x09, 0xbd, 0x1b,
-	0xd8, 0x2a, 0x86, 0x41, 0xe1, 0x8d, 0xbb, 0x2c, 0xaa, 0xdd, 0xf8, 0x3d, 0xbf, 0x9e, 0x5e, 0x9b,
+	0x4f, 0xe1, 0x42, 0x7e, 0xb6, 0xf9, 0xf1, 0xf4, 0x42, 0x4a, 0x9a, 0xeb, 0x45, 0x37, 0x28, 0x9c,
-	0x45, 0x87, 0xe4, 0x9b, 0x82, 0x6f, 0x8b, 0x6a, 0x5f, 0xa1, 0x39, 0x98, 0x2e, 0xf8, 0x41, 0x31,
+	0x71, 0xc7, 0xc5, 0x65, 0x37, 0x3e, 0xcf, 0x5f, 0x6c, 0x5d, 0x6b, 0x45, 0x83, 0xe4, 0x8b, 0x82,
-	0x74, 0x8b, 0x1d, 0xc4, 0x9f, 0xd3, 0xba, 0xa8, 0x30, 0xf8, 0xfb, 0xdd, 0xb8, 0x1e, 0x29, 0xb9,
+	0x2f, 0x8b, 0xcb, 0x3e, 0x45, 0x71, 0x70, 0xb2, 0xe0, 0x4b, 0x45, 0xd7, 0x2d, 0x56, 0x10, 0xbf,
-	0xc2, 0x1d, 0x8b, 0x66, 0x47, 0x89, 0xe5, 0xc3, 0xa2, 0x7a, 0x87, 0x64, 0xaf, 0xad, 0x7e, 0xe5,
+	0x4d, 0xf3, 0xa2, 0xc6, 0x10, 0xe7, 0x77, 0xe3, 0x7c, 0xa4, 0xe5, 0x4a, 0x73, 0x2c, 0x58, 0xf3,
-	0xc6, 0xc2, 0x96, 0x1a, 0x0b, 0x93, 0x71, 0xf7, 0x82, 0x8c, 0x45, 0xac, 0xb5, 0xe5, 0xb8, 0xfb,
+	0x5a, 0xac, 0xb8, 0x2c, 0xea, 0x73, 0x48, 0xd5, 0xda, 0xfa, 0x2b, 0x77, 0x2d, 0x6c, 0xeb, 0x6b,
-	0x25, 0x19, 0x1b, 0xc7, 0x85, 0x4c, 0x91, 0xaa, 0xa9, 0x9c, 0x43, 0xd0, 0xe6, 0x41, 0xaa, 0x4a,
+	0x61, 0x72, 0xdd, 0x3d, 0x22, 0x63, 0xe9, 0x6b, 0x1d, 0x75, 0xdd, 0xfd, 0x84, 0x8c, 0xcd, 0xdd,
-	0xb5, 0xf8, 0x46, 0x9b, 0x00, 0x2e, 0xb5, 0x1c, 0x71, 0xe7, 0x52, 0xa9, 0xae, 0xd9, 0x73, 0x55,
+	0x42, 0xa4, 0xa8, 0xa5, 0xe9, 0x98, 0x43, 0xd0, 0x11, 0x4e, 0xaa, 0x53, 0xb5, 0x1c, 0xa3, 0x35,
-	0x10, 0x38, 0xc6, 0x9f, 0x32, 0xa9, 0x77, 0xe0, 0x05, 0xa7, 0x37, 0x18, 0x95, 0x59, 0x2b, 0x5a,
+	0x00, 0x8f, 0xd9, 0xae, 0xdc, 0x73, 0xb5, 0xa8, 0xae, 0xd5, 0xf3, 0xb4, 0x13, 0xb8, 0xe6, 0x6f,
-	0x39, 0x2b, 0xb2, 0x73, 0x6f, 0x3b, 0x3f, 0xf7, 0x66, 0x92, 0x28, 0xab, 0x8e, 0xba, 0x99, 0x9f,
+	0x32, 0xa1, 0x77, 0xcb, 0xa7, 0xfb, 0x2f, 0xd1, 0x2b, 0xb3, 0x5a, 0xb4, 0x73, 0x5a, 0x64, 0xef,
-	0xc1, 0x06, 0x37, 0x58, 0x62, 0x88, 0x2e, 0xb9, 0xf9, 0x24, 0xf1, 0xef, 0x5b, 0x70, 0xbf, 0x9a,
+	0xbd, 0x9d, 0xfc, 0xbd, 0x37, 0x13, 0x44, 0xd9, 0xe5, 0xe8, 0x9d, 0xf9, 0x10, 0x2e, 0x08, 0x85,
-	0xb8, 0xc9, 0x34, 0xf1, 0x73, 0xd0, 0xd3, 0x6e, 0x9d, 0x3f, 0x29, 0x94, 0xe1, 0x51, 0x98, 0x3e,
+	0x15, 0x86, 0xac, 0x92, 0x9b, 0xdf, 0x24, 0xfe, 0x71, 0x06, 0x2e, 0x56, 0x13, 0x37, 0xb9, 0x4d,
-	0x2a, 0xf2, 0xed, 0x59, 0x57, 0xad, 0xfb, 0x8b, 0xe4, 0x3c, 0x79, 0x59, 0x4a, 0xad, 0x7e, 0xab,
+	0x7c, 0x04, 0x46, 0x5a, 0xad, 0x8b, 0x23, 0x85, 0x71, 0x3c, 0x0a, 0xd3, 0x43, 0x45, 0x9d, 0x3d,
-	0xd4, 0xea, 0x73, 0x01, 0x0e, 0x66, 0x75, 0x02, 0x64, 0xef, 0xb2, 0xee, 0x60, 0x56, 0x27, 0x20,
+	0xab, 0xba, 0x74, 0x7f, 0x90, 0xcc, 0x27, 0x27, 0x4b, 0xa9, 0xd4, 0x6f, 0x97, 0x4a, 0x7d, 0x21,
-	0x25, 0x16, 0x02, 0x64, 0xd4, 0xf4, 0x15, 0xbe, 0x10, 0xb0, 0x09, 0xa0, 0xda, 0x92, 0xd8, 0x4f,
+	0xc0, 0xc5, 0xbc, 0x4e, 0x80, 0xaa, 0x5d, 0x56, 0x5d, 0xcc, 0xeb, 0x04, 0xa4, 0xc4, 0x52, 0x80,
-	0x46, 0x97, 0x9e, 0x6c, 0x4a, 0x62, 0xbf, 0xb6, 0xbb, 0xea, 0xd4, 0x76, 0x57, 0xf9, 0xeb, 0xef,
+	0xf2, 0x9a, 0xbe, 0xc6, 0x97, 0x02, 0xd6, 0x00, 0x74, 0x59, 0x12, 0x07, 0xc9, 0xd5, 0xa5, 0xa7,
-	0x96, 0x5e, 0x88, 0x6f, 0x01, 0x9e, 0xb9, 0xf4, 0x42, 0x3a, 0x99, 0xb7, 0x73, 0x8e, 0x1b, 0xa9,
+	0x8a, 0x92, 0x38, 0xa8, 0xad, 0xae, 0xe6, 0x6b, 0xab, 0xab, 0xfc, 0xf6, 0x77, 0x4b, 0x27, 0xc4,
-	0xd9, 0x97, 0x7f, 0x72, 0x08, 0xf6, 0x3c, 0xe5, 0x3a, 0xfe, 0xc9, 0xc3, 0x37, 0xa6, 0xc4, 0x51,
+	0x97, 0x00, 0xb7, 0x3d, 0x76, 0xa4, 0x8c, 0x2c, 0xca, 0x39, 0xd7, 0x8b, 0xf4, 0xdd, 0x57, 0x0c,
-	0xde, 0x11, 0xdf, 0x1c, 0x76, 0x16, 0x11, 0xa2, 0x1c, 0x20, 0xbe, 0x8d, 0xbf, 0x68, 0xd0, 0xfb,
+	0x05, 0x04, 0xfb, 0xbe, 0x36, 0x9d, 0x18, 0x0a, 0xf7, 0x8d, 0x19, 0x71, 0xb5, 0x75, 0xe4, 0x58,
-	0x8a, 0x8c, 0x14, 0xe7, 0x2d, 0x80, 0x57, 0x41, 0x14, 0xc4, 0xcc, 0xf5, 0x89, 0xec, 0x3e, 0xe7,
+	0xc0, 0x0e, 0x22, 0x42, 0xb4, 0x01, 0xe4, 0xd8, 0xfc, 0x5d, 0x0b, 0x7a, 0x9f, 0x91, 0x91, 0xe6,
-	0xcd, 0x0c, 0xe4, 0x7f, 0x97, 0x23, 0x52, 0x93, 0x78, 0x67, 0xca, 0x99, 0xe2, 0x9b, 0xc3, 0xce,
+	0xbc, 0x0e, 0xf0, 0x98, 0x46, 0x34, 0xe6, 0x5e, 0x40, 0x54, 0xf5, 0x39, 0x6b, 0x65, 0x20, 0xdf,
-	0x09, 0x0e, 0x95, 0xff, 0xc4, 0x37, 0x5a, 0x85, 0x79, 0xca, 0xb0, 0x7d, 0x21, 0x9c, 0xd5, 0x36,
+	0x5c, 0x8e, 0x0c, 0x4d, 0xe2, 0x1f, 0x68, 0x63, 0xca, 0xb1, 0x80, 0x1d, 0x12, 0x1c, 0x6a, 0xfb,
-	0xe5, 0x8f, 0x27, 0xff, 0x5a, 0x83, 0x41, 0xb6, 0x5b, 0x40, 0xdf, 0x43, 0x3f, 0xb3, 0xa9, 0x42,
+	0xc9, 0x31, 0x5a, 0x81, 0x59, 0xc6, 0xb1, 0x73, 0x24, 0x8d, 0xd5, 0xb1, 0xd4, 0x87, 0xf9, 0xaf,
-	0x1f, 0x95, 0x17, 0x52, 0xe5, 0xcd, 0x97, 0xfe, 0x83, 0x19, 0x58, 0x2a, 0x31, 0xe6, 0x90, 0x0f,
+	0x01, 0x0c, 0x3e, 0x8f, 0x49, 0x34, 0xce, 0x74, 0x01, 0x18, 0xd1, 0xd6, 0x49, 0xda, 0x58, 0x19,
-	0xcb, 0xa5, 0x75, 0x0f, 0xda, 0x2d, 0x53, 0xd7, 0x2d, 0x93, 0xf4, 0x47, 0x8d, 0x70, 0x53, 0x79,
+	0x88, 0xd8, 0xc4, 0x83, 0x88, 0x8e, 0xec, 0xb4, 0xd3, 0x75, 0x46, 0xa2, 0xf4, 0x05, 0xf0, 0xae,
-	0x0c, 0x56, 0x2a, 0xf6, 0x37, 0xe8, 0xd3, 0x19, 0x5c, 0x72, 0x3b, 0x24, 0xfd, 0xb3, 0x86, 0xd8,
+	0xea, 0x76, 0xa1, 0x8f, 0x61, 0xee, 0xc0, 0xf3, 0x39, 0x51, 0xbd, 0xa5, 0xfe, 0xf6, 0x9b, 0xe5,
-	0xa9, 0xd4, 0xd7, 0x80, 0xca, 0xcb, 0x1d, 0xf4, 0x68, 0x26, 0x9b, 0xc9, 0xf2, 0x48, 0xff, 0xb4,
+	0xae, 0x56, 0x56, 0xe6, 0xd6, 0x5d, 0x89, 0x6c, 0x69, 0x22, 0xb4, 0x0f, 0xcb, 0x5e, 0x10, 0xca,
-	0x19, 0x72, 0xad, 0xa1, 0x72, 0xed, 0x33, 0xd3, 0xd0, 0xdc, 0x62, 0x69, 0xa6, 0xa1, 0x85, 0x5d,
+	0x6a, 0x28, 0xf2, 0xb0, 0xef, 0x3d, 0x9f, 0xdc, 0x7d, 0xfb, 0xdb, 0xef, 0x4e, 0xe1, 0x75, 0x4f,
-	0xd2, 0x1c, 0xba, 0x80, 0xa5, 0xe2, 0x4a, 0x08, 0x3d, 0xac, 0x5b, 0x61, 0x96, 0x36, 0x4e, 0xfa,
+	0x50, 0xee, 0x65, 0x09, 0x2d, 0xe4, 0x95, 0x60, 0x88, 0xc0, 0x0a, 0x8d, 0x79, 0x59, 0xc8, 0xac,
-	0x6e, 0x13, 0xd4, 0x54, 0x18, 0x81, 0xdb, 0xf9, 0xb5, 0x0d, 0xfa, 0xa4, 0x4c, 0x5f, 0xb9, 0x84,
+	0x14, 0xb2, 0x3d, 0x45, 0xc8, 0x7d, 0x49, 0x9a, 0x97, 0xb2, 0x4c, 0xcb, 0x40, 0x63, 0x17, 0xe6,
-	0xd2, 0x77, 0x66, 0x23, 0x66, 0x6d, 0x2a, 0xae, 0x72, 0xaa, 0x6c, 0xaa, 0xd9, 0x13, 0x55, 0xd9,
+	0x94, 0x72, 0xc2, 0xfc, 0x07, 0x1e, 0xf1, 0x93, 0xee, 0x9c, 0xfa, 0x10, 0x29, 0x86, 0x86, 0x24,
-	0x54, 0xb7, 0x19, 0x32, 0xe6, 0xd0, 0xef, 0x93, 0xfd, 0x40, 0x61, 0xc5, 0x81, 0xf6, 0xea, 0xd8,
+	0xc2, 0x81, 0xab, 0x53, 0x53, 0xf2, 0x29, 0xf0, 0x8f, 0xb1, 0x1f, 0x93, 0xa4, 0x3d, 0x27, 0x3f,
-	0x54, 0xef, 0x58, 0xf4, 0xfd, 0xc6, 0xf8, 0x89, 0xec, 0xc7, 0x1a, 0xcf, 0xf5, 0xcc, 0xa6, 0xa3,
+	0x8c, 0xbf, 0xcd, 0x02, 0x2a, 0x6b, 0x98, 0x5c, 0xe8, 0x23, 0xc2, 0x84, 0xd3, 0xdb, 0x7c, 0x1c,
-	0x2a, 0xd7, 0xcb, 0xbb, 0x93, 0xaa, 0x5c, 0xaf, 0x5a, 0x97, 0xcc, 0xa1, 0x53, 0x58, 0xcc, 0xed,
+	0x12, 0x2d, 0x67, 0x31, 0x03, 0x7f, 0x30, 0x0e, 0x09, 0xfa, 0x09, 0xf4, 0x1c, 0x76, 0x6c, 0x4b,
-	0x3e, 0xd0, 0xc7, 0x75, 0x94, 0xf9, 0xa6, 0x49, 0xff, 0x64, 0x26, 0x5e, 0x2a, 0xc3, 0x4a, 0xaa,
+	0x93, 0x48, 0x99, 0xfd, 0xed, 0x0f, 0x4f, 0x6d, 0xd2, 0xad, 0x9d, 0xbd, 0x87, 0x12, 0x6a, 0x75,
-	0x97, 0x2a, 0x57, 0xb5, 0xca, 0xe5, 0xeb, 0xd5, 0xc7, 0xb3, 0xd0, 0x72, 0xa9, 0x5c, 0xda, 0x90,
+	0x1d, 0x76, 0x2c, 0x47, 0xe8, 0x67, 0x00, 0xbf, 0x60, 0x34, 0xd0, 0x9c, 0xd5, 0xc6, 0x7f, 0x74,
-	0x54, 0xa6, 0x72, 0xdd, 0x06, 0xa6, 0x32, 0x95, 0xeb, 0x97, 0x2e, 0x73, 0xe8, 0x77, 0x00, 0x93,
+	0x7a, 0xce, 0x3f, 0xda, 0xbb, 0xbf, 0xab, 0x58, 0xf7, 0x04, 0x3b, 0xc5, 0xdb, 0x81, 0x85, 0x10,
-	0x2d, 0x06, 0xfa, 0xb0, 0x8e, 0x3a, 0x7b, 0xfb, 0x1f, 0x4d, 0x47, 0x4a, 0x59, 0xbf, 0x81, 0xd5,
+	0x47, 0x4f, 0x62, 0xc2, 0x35, 0x7b, 0xe5, 0x0b, 0xdf, 0x3d, 0x3d, 0xfb, 0x1f, 0x2b, 0x36, 0x4a,
-	0xaa, 0xe6, 0x02, 0x55, 0x24, 0xfe, 0x94, 0x0e, 0x46, 0xdf, 0x6b, 0x8a, 0x9e, 0x0a, 0xfe, 0x06,
+	0xc2, 0x20, 0xcc, 0x7c, 0x19, 0x7f, 0x39, 0x03, 0xdd, 0x44, 0x2f, 0x51, 0x50, 0x49, 0x0f, 0x57,
-	0xba, 0xc9, 0x06, 0x02, 0x7d, 0x50, 0xa6, 0x2e, 0xec, 0x5c, 0x74, 0x63, 0x1a, 0x4a, 0x26, 0x80,
+	0xd7, 0x0a, 0xdb, 0x0b, 0x0e, 0xa8, 0xb6, 0xe8, 0x59, 0x01, 0x57, 0x37, 0x8b, 0x7b, 0xc1, 0x01,
-	0x47, 0x49, 0xae, 0x4e, 0x56, 0x03, 0xf5, 0xb9, 0x5a, 0x5a, 0x62, 0xd4, 0xe7, 0x6a, 0x79, 0xd3,
+	0x15, 0xb6, 0x8f, 0x88, 0x43, 0x23, 0x57, 0x1c, 0x5f, 0xde, 0xc8, 0x13, 0x6e, 0xaf, 0xf6, 0x72,
-	0x20, 0xc4, 0xa5, 0xc1, 0x90, 0x9d, 0xa4, 0xeb, 0x83, 0xa1, 0x62, 0x51, 0x50, 0x1f, 0x0c, 0x95,
+	0x51, 0xc1, 0x6f, 0x27, 0x60, 0x74, 0x19, 0x16, 0xe5, 0xb6, 0x67, 0x30, 0xdb, 0x09, 0x4f, 0xe2,
-	0xc3, 0xf9, 0x1c, 0xfa, 0x03, 0xac, 0x55, 0x0f, 0xd0, 0xa8, 0x36, 0xe3, 0x6b, 0x06, 0x79, 0xfd,
+	0x67, 0x10, 0xaf, 0xc0, 0xd2, 0x93, 0x98, 0x72, 0x62, 0x3b, 0x87, 0x38, 0xc2, 0x0e, 0xa7, 0x69,
-	0x71, 0x73, 0x82, 0x54, 0xfc, 0xbb, 0xa4, 0x3e, 0x15, 0x06, 0xe8, 0xfa, 0xfa, 0x54, 0x3d, 0xc6,
+	0x81, 0xbf, 0x28, 0xe1, 0x3b, 0x29, 0x18, 0xfd, 0x1f, 0x9c, 0x57, 0xa8, 0x84, 0x39, 0x38, 0x4c,
-	0xeb, 0xfb, 0x8d, 0xf1, 0xcb, 0xa9, 0x97, 0x9d, 0x54, 0xeb, 0xbd, 0x5d, 0x31, 0x94, 0xd7, 0x7b,
+	0x29, 0x48, 0xa4, 0xeb, 0xbf, 0x15, 0x39, 0x7b, 0x47, 0x4e, 0xee, 0x24, 0x73, 0xc8, 0x80, 0xae,
-	0xbb, 0x72, 0xf8, 0x15, 0xf9, 0x51, 0x35, 0x85, 0x56, 0xe5, 0xc7, 0x94, 0x31, 0x59, 0xdf, 0x6b,
+	0x43, 0x47, 0x23, 0x12, 0x70, 0x26, 0x93, 0x44, 0xcf, 0x4a, 0xbf, 0xd1, 0x4d, 0x58, 0xc3, 0xbe,
-	0x8a, 0x9e, 0x7b, 0xbe, 0xcb, 0x63, 0x26, 0x9a, 0xa9, 0x7f, 0xae, 0x32, 0x7f, 0xd6, 0x10, 0xbb,
+	0x4f, 0x9f, 0xda, 0x92, 0xd2, 0xb5, 0x4b, 0xda, 0xcd, 0xcb, 0xe3, 0xd9, 0x90, 0x48, 0x9f, 0x4b,
-	0xfe, 0x76, 0x93, 0x4a, 0x3d, 0xd3, 0x80, 0x42, 0xc5, 0xde, 0x6f, 0x8c, 0x9f, 0xca, 0x0e, 0x93,
+	0x1c, 0x2b, 0xaf, 0xa8, 0x71, 0x09, 0x7a, 0xe9, 0x3e, 0x8a, 0x64, 0x94, 0x71, 0x48, 0x39, 0x36,
-	0xdd, 0x72, 0x66, 0x44, 0x44, 0xbb, 0x33, 0xf8, 0x64, 0x46, 0x5c, 0xfd, 0x51, 0x23, 0xdc, 0xaa,
+	0xce, 0xc2, 0x20, 0xbb, 0x13, 0xc6, 0x3f, 0xdb, 0xb0, 0x5c, 0x11, 0x54, 0xe8, 0x11, 0x80, 0xf0,
-	0xec, 0xcd, 0x0e, 0x6d, 0xd3, 0xe2, 0xa9, 0x34, 0x69, 0x4e, 0x8b, 0xa7, 0x8a, 0x39, 0x70, 0xee,
+	0x56, 0x15, 0x5a, 0xda, 0x5d, 0xbf, 0x73, 0xfa, 0xe0, 0x14, 0xfe, 0xaa, 0xc0, 0x96, 0xf0, 0x7e,
-	0x74, 0x41, 0xfc, 0x81, 0xfc, 0xf9, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x44, 0x1a, 0xc5,
+	0x35, 0x44, 0x3f, 0x87, 0xbe, 0xf4, 0x58, 0xcd, 0x5d, 0xb9, 0xec, 0xc7, 0xdf, 0x80, 0xbb, 0xd0,
-	0x57, 0x1e, 0x00, 0x00,
+	0x55, 0xb3, 0x97, 0x31, 0xa0, 0xc6, 0xc6, 0xdf, 0x5b, 0xd0, 0x4b, 0x05, 0x8b, 0x0b, 0xb7, 0xda,
+	0x28, 0xb9, 0xd7, 0x4c, 0x9b, 0xa3, 0x2f, 0x61, 0x77, 0x25, 0xe8, 0x7f, 0xd2, 0x95, 0x8c, 0xf7,
+	0x01, 0x26, 0xfa, 0x57, 0xaa, 0xd0, 0xaa, 0x54, 0xc1, 0xbc, 0x02, 0x0b, 0xc2, 0xb2, 0x1e, 0x71,
+	0xf7, 0x78, 0xe4, 0x85, 0xf2, 0x9d, 0x41, 0xe1, 0x30, 0x5d, 0x1b, 0x26, 0x9f, 0xdb, 0xbf, 0x5f,
+	0x85, 0x41, 0xf6, 0x4e, 0x8b, 0xbe, 0x82, 0x7e, 0xe6, 0x3d, 0x05, 0xbd, 0x51, 0xde, 0xb4, 0xf2,
+	0xfb, 0x8c, 0xf1, 0xe6, 0x14, 0x2c, 0x5d, 0xbe, 0xcd, 0xa0, 0x00, 0xce, 0x95, 0x1e, 0x25, 0xd0,
+	0xd5, 0x32, 0x75, 0xdd, 0x93, 0x87, 0x71, 0xad, 0x11, 0x6e, 0x2a, 0x8f, 0xc3, 0x72, 0xc5, 0x2b,
+	0x03, 0x7a, 0x7b, 0x0a, 0x97, 0xdc, 0x4b, 0x87, 0xf1, 0x4e, 0x43, 0xec, 0x54, 0xea, 0x13, 0x40,
+	0xe5, 0x27, 0x08, 0x74, 0x6d, 0x2a, 0x9b, 0xc9, 0x13, 0x87, 0xf1, 0x76, 0x33, 0xe4, 0x5a, 0x45,
+	0xd5, 0xe3, 0xc4, 0x54, 0x45, 0x73, 0xcf, 0x1f, 0x53, 0x15, 0x2d, 0xbc, 0x78, 0xcc, 0xa0, 0x23,
+	0x58, 0x2a, 0x3e, 0x5c, 0xa0, 0x2b, 0x75, 0x0f, 0x6d, 0xa5, 0x77, 0x11, 0xe3, 0x6a, 0x13, 0xd4,
+	0x54, 0x18, 0x81, 0xb3, 0xf9, 0xc7, 0x05, 0x74, 0xb9, 0x4c, 0x5f, 0xf9, 0x54, 0x62, 0x6c, 0x4e,
+	0x47, 0xcc, 0xea, 0x54, 0x7c, 0x70, 0xa8, 0xd2, 0xa9, 0xe6, 0x35, 0xa3, 0x4a, 0xa7, 0xba, 0xf7,
+	0x0b, 0x73, 0x06, 0xfd, 0x32, 0xe9, 0x62, 0x17, 0x1a, 0xf1, 0x68, 0xab, 0x8e, 0x4d, 0xf5, 0x4b,
+	0x80, 0x71, 0xbd, 0x31, 0x7e, 0x22, 0xfb, 0x46, 0x4b, 0xc4, 0x7a, 0xa6, 0x1f, 0x5f, 0x15, 0xeb,
+	0xe5, 0x0e, 0x7f, 0x55, 0xac, 0x57, 0x35, 0xf5, 0x67, 0xd0, 0x3e, 0x2c, 0xe4, 0x3a, 0xf4, 0xe8,
+	0xad, 0x3a, 0xca, 0xfc, 0xd5, 0xde, 0xb8, 0x3c, 0x15, 0x2f, 0x95, 0x61, 0x27, 0xd9, 0x4b, 0xa7,
+	0xab, 0xda, 0xc5, 0xe5, 0xf3, 0xd5, 0x5b, 0xd3, 0xd0, 0x72, 0xa1, 0x5c, 0xea, 0xe3, 0x57, 0x86,
+	0x72, 0xdd, 0x3b, 0x41, 0x65, 0x28, 0xd7, 0x3f, 0x0d, 0xcc, 0xa0, 0x9f, 0x02, 0x4c, 0x7a, 0xed,
+	0xe8, 0xf5, 0x3a, 0xea, 0xec, 0xee, 0xbf, 0x71, 0x32, 0x52, 0xca, 0xfa, 0x29, 0xac, 0x54, 0x5d,
+	0x81, 0x51, 0x45, 0xe0, 0x9f, 0x70, 0xcf, 0x36, 0xb6, 0x9a, 0xa2, 0xa7, 0x82, 0xbf, 0x80, 0x6e,
+	0xd2, 0x27, 0x47, 0xaf, 0x95, 0xa9, 0x0b, 0x2f, 0x03, 0x86, 0x79, 0x12, 0x4a, 0xc6, 0x81, 0x47,
+	0x49, 0xac, 0x4e, 0x1a, 0xd8, 0xf5, 0xb1, 0x5a, 0x6a, 0xb5, 0xd7, 0xc7, 0x6a, 0xb9, 0x1f, 0x2e,
+	0xc5, 0xa5, 0xce, 0x90, 0xed, 0xf7, 0xd6, 0x3b, 0x43, 0x45, 0x3b, 0xbb, 0xde, 0x19, 0x2a, 0x5b,
+	0xc8, 0x33, 0xe8, 0x57, 0x70, 0xbe, 0xba, 0xcd, 0x8b, 0x6a, 0x23, 0xbe, 0xa6, 0xdd, 0x6c, 0xdc,
+	0x68, 0x4e, 0x90, 0x8a, 0x7f, 0x9e, 0xe4, 0xa7, 0x42, 0x9b, 0xb7, 0x3e, 0x3f, 0x55, 0x37, 0x9b,
+	0x8d, 0xeb, 0x8d, 0xf1, 0xcb, 0xa1, 0x97, 0xed, 0xa7, 0xd6, 0x5b, 0xbb, 0xa2, 0x75, 0x5c, 0x6f,
+	0xed, 0xca, 0x16, 0xad, 0x8c, 0x8f, 0xaa, 0x5e, 0x69, 0x55, 0x7c, 0x9c, 0xd0, 0xcc, 0x35, 0xb6,
+	0x9a, 0xa2, 0xe7, 0x8e, 0xef, 0x72, 0x33, 0x14, 0x4d, 0x5d, 0x7f, 0x2e, 0x33, 0xbf, 0xd3, 0x10,
+	0xbb, 0x7e, 0x77, 0x93, 0x4c, 0x3d, 0x55, 0x81, 0x42, 0xc6, 0xbe, 0xde, 0x18, 0x3f, 0x95, 0x1d,
+	0x26, 0x2f, 0xa0, 0x99, 0x46, 0x26, 0xba, 0x3a, 0x85, 0x4f, 0xa6, 0x11, 0x6b, 0x5c, 0x6b, 0x84,
+	0x5b, 0x15, 0xbd, 0xd9, 0xd6, 0xe2, 0x49, 0xfe, 0x54, 0xea, 0x87, 0x9e, 0xe4, 0x4f, 0x15, 0xdd,
+	0xca, 0x19, 0xf4, 0x29, 0xcc, 0xca, 0x2b, 0x0e, 0x5a, 0x3f, 0xf9, 0xee, 0x63, 0x5c, 0xaa, 0x9e,
+	0x4f, 0x2b, 0x78, 0xa1, 0xc0, 0xfe, 0x9c, 0xfc, 0x69, 0xea, 0xbd, 0xff, 0x04, 0x00, 0x00, 0xff,
+	0xff, 0x03, 0xe0, 0xe6, 0x48, 0x4b, 0x25, 0x00, 0x00,
 }

weed/query/json/query_json.go

@@ -0,0 +1,107 @@
+package json
+
+import (
+	"strconv"
+
+	"github.com/chrislusf/seaweedfs/weed/query/sqltypes"
+	"github.com/tidwall/gjson"
+	"github.com/tidwall/match"
+)
+
+type Query struct {
+	Field string
+	Op    string
+	Value string
+}
+
+func QueryJson(jsonLine string, projections []string, query Query) (passedFilter bool, values []sqltypes.Value) {
+	if filterJson(jsonLine, query) {
+		passedFilter = true
+		fields := gjson.GetMany(jsonLine, projections...)
+		for _, f := range fields {
+			values = append(values, sqltypes.MakeTrusted(sqltypes.Type(f.Type), sqltypes.StringToBytes(f.Raw)))
+		}
+		return
+	}
+	return false, nil
+}
+
+func filterJson(jsonLine string, query Query) bool {
+
+	value := gjson.Get(jsonLine, query.Field)
+
+	// copied from gjson.go queryMatches() function
+	rpv := query.Value
+
+	if !value.Exists() {
+		return false
+	}
+	if query.Op == "" {
+		// the query is only looking for existence, such as:
+		//   friends.#(name)
+		// which makes sure that the array "friends" has an element of
+		// "name" that exists
+		return true
+	}
+	switch value.Type {
+	case gjson.String:
+		switch query.Op {
+		case "=":
+			return value.Str == rpv
+		case "!=":
+			return value.Str != rpv
+		case "<":
+			return value.Str < rpv
+		case "<=":
+			return value.Str <= rpv
+		case ">":
+			return value.Str > rpv
+		case ">=":
+			return value.Str >= rpv
+		case "%":
+			return match.Match(value.Str, rpv)
+		case "!%":
+			return !match.Match(value.Str, rpv)
+		}
+	case gjson.Number:
+		rpvn, _ := strconv.ParseFloat(rpv, 64)
+		switch query.Op {
+		case "=":
+			return value.Num == rpvn
+		case "!=":
+			return value.Num != rpvn
+		case "<":
+			return value.Num < rpvn
+		case "<=":
+			return value.Num <= rpvn
+		case ">":
+			return value.Num > rpvn
+		case ">=":
+			return value.Num >= rpvn
+		}
+	case gjson.True:
+		switch query.Op {
+		case "=":
+			return rpv == "true"
+		case "!=":
+			return rpv != "true"
+		case ">":
+			return rpv == "false"
+		case ">=":
+			return true
+		}
+	case gjson.False:
+		switch query.Op {
+		case "=":
+			return rpv == "false"
+		case "!=":
+			return rpv != "false"
+		case "<":
+			return rpv == "true"
+		case "<=":
+			return true
+		}
+	}
+	return false
+
+}

weed/query/json/query_json_test.go

@@ -0,0 +1,133 @@
+package json
+
+import (
+	"testing"
+
+	"github.com/tidwall/gjson"
+)
+
+func TestGjson(t *testing.T) {
+	data := `
+	{
+		"quiz": {
+			"sport": {
+				"q1": {
+					"question": "Which one is correct team name in NBA?",
+					"options": [
+						"New York Bulls",
+						"Los Angeles Kings",
+						"Golden State Warriros",
+						"Huston Rocket"
+					],
+					"answer": "Huston Rocket"
+				}
+			},
+			"maths": {
+				"q1": {
+					"question": "5 + 7 = ?",
+					"options": [
+						"10",
+						"11",
+						"12",
+						"13"
+					],
+					"answer": "12"
+				},
+				"q2": {
+					"question": "12 - 8 = ?",
+					"options": [
+						"1",
+						"2",
+						"3",
+						"4"
+					],
+					"answer": "4"
+				}
+			}
+		}
+	}
+
+	{
+		"fruit": "Apple",
+		"size": "Large",
+		"quiz": "Red"
+	}
+
+`
+
+	projections := []string{"quiz", "fruit"}
+
+	gjson.ForEachLine(data, func(line gjson.Result) bool {
+		println(line.Raw)
+		println("+++++++++++")
+		results := gjson.GetMany(line.Raw, projections...)
+		for _, result := range results {
+			println(result.Index, result.Type, result.String())
+		}
+		println("-----------")
+		return true
+	})
+
+}
+
+func TestJsonQueryRow(t *testing.T) {
+
+	data := `
+	{
+		"fruit": "Bl\"ue",
+		"size": 6,
+		"quiz": "green"
+	}
+
+`
+	selections := []string{"fruit", "size"}
+
+	isFiltered, values := QueryJson(data, selections, Query{
+		Field: "quiz",
+		Op:    "=",
+		Value: "green",
+	})
+
+	if !isFiltered {
+		t.Errorf("should have been filtered")
+	}
+
+	if values == nil {
+		t.Errorf("values should have been returned")
+	}
+
+	buf := ToJson(nil, selections, values)
+	println(string(buf))
+
+}
+
+func TestJsonQueryNumber(t *testing.T) {
+
+	data := `
+	{
+		"fruit": "Bl\"ue",
+		"size": 6,
+		"quiz": "green"
+	}
+
+`
+	selections := []string{"fruit", "quiz"}
+
+	isFiltered, values := QueryJson(data, selections, Query{
+		Field: "size",
+		Op:    ">=",
+		Value: "6",
+	})
+
+	if !isFiltered {
+		t.Errorf("should have been filtered")
+	}
+
+	if values == nil {
+		t.Errorf("values should have been returned")
+	}
+
+	buf := ToJson(nil, selections, values)
+	println(string(buf))
+
+}

weed/query/json/seralize.go

@@ -0,0 +1,17 @@
+package json
+
+import "github.com/chrislusf/seaweedfs/weed/query/sqltypes"
+
+func ToJson(buf []byte, selections []string, values []sqltypes.Value) []byte {
+	buf = append(buf, '{')
+	for i, value := range values {
+		if i > 0 {
+			buf = append(buf, ',')
+		}
+		buf = append(buf, selections[i]...)
+		buf = append(buf, ':')
+		buf = append(buf, value.Raw()...)
+	}
+	buf = append(buf, '}')
+	return buf
+}

weed/query/sqltypes/const.go

@@ -0,0 +1,124 @@
+package sqltypes
+
+// copied from vitness
+
+// Flag allows us to qualify types by their common properties.
+type Flag int32
+
+const (
+	Flag_NONE       Flag = 0
+	Flag_ISINTEGRAL Flag = 256
+	Flag_ISUNSIGNED Flag = 512
+	Flag_ISFLOAT    Flag = 1024
+	Flag_ISQUOTED   Flag = 2048
+	Flag_ISTEXT     Flag = 4096
+	Flag_ISBINARY   Flag = 8192
+)
+
+var Flag_name = map[int32]string{
+	0:    "NONE",
+	256:  "ISINTEGRAL",
+	512:  "ISUNSIGNED",
+	1024: "ISFLOAT",
+	2048: "ISQUOTED",
+	4096: "ISTEXT",
+	8192: "ISBINARY",
+}
+var Flag_value = map[string]int32{
+	"NONE":       0,
+	"ISINTEGRAL": 256,
+	"ISUNSIGNED": 512,
+	"ISFLOAT":    1024,
+	"ISQUOTED":   2048,
+	"ISTEXT":     4096,
+	"ISBINARY":   8192,
+}
+
+// Type defines the various supported data types in bind vars
+// and query results.
+type Type int32
+
+const (
+	// NULL_TYPE specifies a NULL type.
+	Type_NULL_TYPE Type = 0
+	// INT8 specifies a TINYINT type.
+	// Properties: 1, IsNumber.
+	Type_INT8 Type = 257
+	// UINT8 specifies a TINYINT UNSIGNED type.
+	// Properties: 2, IsNumber, IsUnsigned.
+	Type_UINT8 Type = 770
+	// INT16 specifies a SMALLINT type.
+	// Properties: 3, IsNumber.
+	Type_INT16 Type = 259
+	// UINT16 specifies a SMALLINT UNSIGNED type.
+	// Properties: 4, IsNumber, IsUnsigned.
+	Type_UINT16 Type = 772
+	// INT24 specifies a MEDIUMINT type.
+	// Properties: 5, IsNumber.
+	Type_INT32 Type = 263
+	// UINT32 specifies a INTEGER UNSIGNED type.
+	// Properties: 8, IsNumber, IsUnsigned.
+	Type_UINT32 Type = 776
+	// INT64 specifies a BIGINT type.
+	// Properties: 9, IsNumber.
+	Type_INT64 Type = 265
+	// UINT64 specifies a BIGINT UNSIGNED type.
+	// Properties: 10, IsNumber, IsUnsigned.
+	Type_UINT64 Type = 778
+	// FLOAT32 specifies a FLOAT type.
+	// Properties: 11, IsFloat.
+	Type_FLOAT32 Type = 1035
+	// FLOAT64 specifies a DOUBLE or REAL type.
+	// Properties: 12, IsFloat.
+	Type_FLOAT64 Type = 1036
+	// TIMESTAMP specifies a TIMESTAMP type.
+	// Properties: 13, IsQuoted.
+	Type_TIMESTAMP Type = 2061
+	// DATE specifies a DATE type.
+	// Properties: 14, IsQuoted.
+	Type_DATE Type = 2062
+	// TIME specifies a TIME type.
+	// Properties: 15, IsQuoted.
+	Type_TIME Type = 2063
+	// DATETIME specifies a DATETIME type.
+	// Properties: 16, IsQuoted.
+	Type_DATETIME Type = 2064
+	// YEAR specifies a YEAR type.
+	// Properties: 17, IsNumber, IsUnsigned.
+	Type_YEAR Type = 785
+	// DECIMAL specifies a DECIMAL or NUMERIC type.
+	// Properties: 18, None.
+	Type_DECIMAL Type = 18
+	// TEXT specifies a TEXT type.
+	// Properties: 19, IsQuoted, IsText.
+	Type_TEXT Type = 6163
+	// BLOB specifies a BLOB type.
+	// Properties: 20, IsQuoted, IsBinary.
+	Type_BLOB Type = 10260
+	// VARCHAR specifies a VARCHAR type.
+	// Properties: 21, IsQuoted, IsText.
+	Type_VARCHAR Type = 6165
+	// VARBINARY specifies a VARBINARY type.
+	// Properties: 22, IsQuoted, IsBinary.
+	Type_VARBINARY Type = 10262
+	// CHAR specifies a CHAR type.
+	// Properties: 23, IsQuoted, IsText.
+	Type_CHAR Type = 6167
+	// BINARY specifies a BINARY type.
+	// Properties: 24, IsQuoted, IsBinary.
+	Type_BINARY Type = 10264
+	// BIT specifies a BIT type.
+	// Properties: 25, IsQuoted.
+	Type_BIT Type = 2073
+	// JSON specifies a JSON type.
+	// Properties: 30, IsQuoted.
+	Type_JSON Type = 2078
+)
+
+// BindVariable represents a single bind variable in a Query.
+type BindVariable struct {
+	Type  Type   `protobuf:"varint,1,opt,name=type,enum=query.Type" json:"type,omitempty"`
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	// values are set if type is TUPLE.
+	Values []*Value `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
+}

weed/query/sqltypes/type.go

@@ -0,0 +1,101 @@
+package sqltypes
+
+// These bit flags can be used to query on the
+// common properties of types.
+const (
+	flagIsIntegral = int(Flag_ISINTEGRAL)
+	flagIsUnsigned = int(Flag_ISUNSIGNED)
+	flagIsFloat    = int(Flag_ISFLOAT)
+	flagIsQuoted   = int(Flag_ISQUOTED)
+	flagIsText     = int(Flag_ISTEXT)
+	flagIsBinary   = int(Flag_ISBINARY)
+)
+
+// IsIntegral returns true if Type is an integral
+// (signed/unsigned) that can be represented using
+// up to 64 binary bits.
+// If you have a Value object, use its member function.
+func IsIntegral(t Type) bool {
+	return int(t)&flagIsIntegral == flagIsIntegral
+}
+
+// IsSigned returns true if Type is a signed integral.
+// If you have a Value object, use its member function.
+func IsSigned(t Type) bool {
+	return int(t)&(flagIsIntegral|flagIsUnsigned) == flagIsIntegral
+}
+
+// IsUnsigned returns true if Type is an unsigned integral.
+// Caution: this is not the same as !IsSigned.
+// If you have a Value object, use its member function.
+func IsUnsigned(t Type) bool {
+	return int(t)&(flagIsIntegral|flagIsUnsigned) == flagIsIntegral|flagIsUnsigned
+}
+
+// IsFloat returns true is Type is a floating point.
+// If you have a Value object, use its member function.
+func IsFloat(t Type) bool {
+	return int(t)&flagIsFloat == flagIsFloat
+}
+
+// IsQuoted returns true if Type is a quoted text or binary.
+// If you have a Value object, use its member function.
+func IsQuoted(t Type) bool {
+	return (int(t)&flagIsQuoted == flagIsQuoted) && t != Bit
+}
+
+// IsText returns true if Type is a text.
+// If you have a Value object, use its member function.
+func IsText(t Type) bool {
+	return int(t)&flagIsText == flagIsText
+}
+
+// IsBinary returns true if Type is a binary.
+// If you have a Value object, use its member function.
+func IsBinary(t Type) bool {
+	return int(t)&flagIsBinary == flagIsBinary
+}
+
+// isNumber returns true if the type is any type of number.
+func isNumber(t Type) bool {
+	return IsIntegral(t) || IsFloat(t) || t == Decimal
+}
+
+// IsTemporal returns true if Value is time type.
+func IsTemporal(t Type) bool {
+	switch t {
+	case Timestamp, Date, Time, Datetime:
+		return true
+	}
+	return false
+}
+
+// Vitess data types. These are idiomatically
+// named synonyms for the Type values.
+const (
+	Null      = Type_NULL_TYPE
+	Int8      = Type_INT8
+	Uint8     = Type_UINT8
+	Int16     = Type_INT16
+	Uint16    = Type_UINT16
+	Int32     = Type_INT32
+	Uint32    = Type_UINT32
+	Int64     = Type_INT64
+	Uint64    = Type_UINT64
+	Float32   = Type_FLOAT32
+	Float64   = Type_FLOAT64
+	Timestamp = Type_TIMESTAMP
+	Date      = Type_DATE
+	Time      = Type_TIME
+	Datetime  = Type_DATETIME
+	Year      = Type_YEAR
+	Decimal   = Type_DECIMAL
+	Text      = Type_TEXT
+	Blob      = Type_BLOB
+	VarChar   = Type_VARCHAR
+	VarBinary = Type_VARBINARY
+	Char      = Type_CHAR
+	Binary    = Type_BINARY
+	Bit       = Type_BIT
+	TypeJSON  = Type_JSON
+)

weed/query/sqltypes/unsafe.go

@@ -0,0 +1,30 @@
+package sqltypes
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// BytesToString casts slice to string without copy
+func BytesToString(b []byte) (s string) {
+	if len(b) == 0 {
+		return ""
+	}
+
+	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sh := reflect.StringHeader{Data: bh.Data, Len: bh.Len}
+
+	return *(*string)(unsafe.Pointer(&sh))
+}
+
+// StringToBytes casts string to slice without copy
+func StringToBytes(s string) []byte {
+	if len(s) == 0 {
+		return []byte{}
+	}
+
+	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := reflect.SliceHeader{Data: sh.Data, Len: sh.Len, Cap: sh.Len}
+
+	return *(*[]byte)(unsafe.Pointer(&bh))
+}

weed/query/sqltypes/value.go

@@ -0,0 +1,355 @@
+package sqltypes
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+)
+
+var (
+	// NULL represents the NULL value.
+	NULL = Value{}
+	// DontEscape tells you if a character should not be escaped.
+	DontEscape = byte(255)
+	nullstr    = []byte("null")
+)
+
+type Value struct {
+	typ Type
+	val []byte
+}
+
+// NewValue builds a Value using typ and val. If the value and typ
+// don't match, it returns an error.
+func NewValue(typ Type, val []byte) (v Value, err error) {
+	switch {
+	case IsSigned(typ):
+		if _, err := strconv.ParseInt(string(val), 0, 64); err != nil {
+			return NULL, err
+		}
+		return MakeTrusted(typ, val), nil
+	case IsUnsigned(typ):
+		if _, err := strconv.ParseUint(string(val), 0, 64); err != nil {
+			return NULL, err
+		}
+		return MakeTrusted(typ, val), nil
+	case IsFloat(typ) || typ == Decimal:
+		if _, err := strconv.ParseFloat(string(val), 64); err != nil {
+			return NULL, err
+		}
+		return MakeTrusted(typ, val), nil
+	case IsQuoted(typ) || typ == Bit || typ == Null:
+		return MakeTrusted(typ, val), nil
+	}
+	// All other types are unsafe or invalid.
+	return NULL, fmt.Errorf("invalid type specified for MakeValue: %v", typ)
+}
+
+// MakeTrusted makes a new Value based on the type.
+// This function should only be used if you know the value
+// and type conform to the rules. Every place this function is
+// called, a comment is needed that explains why it's justified.
+// Exceptions: The current package and mysql package do not need
+// comments. Other packages can also use the function to create
+// VarBinary or VarChar values.
+func MakeTrusted(typ Type, val []byte) Value {
+
+	if typ == Null {
+		return NULL
+	}
+
+	return Value{typ: typ, val: val}
+}
+
+// NewInt64 builds an Int64 Value.
+func NewInt64(v int64) Value {
+	return MakeTrusted(Int64, strconv.AppendInt(nil, v, 10))
+}
+
+// NewInt32 builds an Int64 Value.
+func NewInt32(v int32) Value {
+	return MakeTrusted(Int32, strconv.AppendInt(nil, int64(v), 10))
+}
+
+// NewUint64 builds an Uint64 Value.
+func NewUint64(v uint64) Value {
+	return MakeTrusted(Uint64, strconv.AppendUint(nil, v, 10))
+}
+
+// NewFloat32 builds an Float64 Value.
+func NewFloat32(v float32) Value {
+	return MakeTrusted(Float32, strconv.AppendFloat(nil, float64(v), 'f', -1, 64))
+}
+
+// NewFloat64 builds an Float64 Value.
+func NewFloat64(v float64) Value {
+	return MakeTrusted(Float64, strconv.AppendFloat(nil, v, 'g', -1, 64))
+}
+
+// NewVarChar builds a VarChar Value.
+func NewVarChar(v string) Value {
+	return MakeTrusted(VarChar, []byte(v))
+}
+
+// NewVarBinary builds a VarBinary Value.
+// The input is a string because it's the most common use case.
+func NewVarBinary(v string) Value {
+	return MakeTrusted(VarBinary, []byte(v))
+}
+
+// NewIntegral builds an integral type from a string representation.
+// The type will be Int64 or Uint64. Int64 will be preferred where possible.
+func NewIntegral(val string) (n Value, err error) {
+	signed, err := strconv.ParseInt(val, 0, 64)
+	if err == nil {
+		return MakeTrusted(Int64, strconv.AppendInt(nil, signed, 10)), nil
+	}
+	unsigned, err := strconv.ParseUint(val, 0, 64)
+	if err != nil {
+		return Value{}, err
+	}
+	return MakeTrusted(Uint64, strconv.AppendUint(nil, unsigned, 10)), nil
+}
+
+// MakeString makes a VarBinary Value.
+func MakeString(val []byte) Value {
+	return MakeTrusted(VarBinary, val)
+}
+
+// BuildValue builds a value from any go type. sqltype.Value is
+// also allowed.
+func BuildValue(goval interface{}) (v Value, err error) {
+	// Look for the most common types first.
+	switch goval := goval.(type) {
+	case nil:
+		// no op
+	case []byte:
+		v = MakeTrusted(VarBinary, goval)
+	case int64:
+		v = MakeTrusted(Int64, strconv.AppendInt(nil, int64(goval), 10))
+	case uint64:
+		v = MakeTrusted(Uint64, strconv.AppendUint(nil, uint64(goval), 10))
+	case float64:
+		v = MakeTrusted(Float64, strconv.AppendFloat(nil, goval, 'f', -1, 64))
+	case int:
+		v = MakeTrusted(Int64, strconv.AppendInt(nil, int64(goval), 10))
+	case int8:
+		v = MakeTrusted(Int8, strconv.AppendInt(nil, int64(goval), 10))
+	case int16:
+		v = MakeTrusted(Int16, strconv.AppendInt(nil, int64(goval), 10))
+	case int32:
+		v = MakeTrusted(Int32, strconv.AppendInt(nil, int64(goval), 10))
+	case uint:
+		v = MakeTrusted(Uint64, strconv.AppendUint(nil, uint64(goval), 10))
+	case uint8:
+		v = MakeTrusted(Uint8, strconv.AppendUint(nil, uint64(goval), 10))
+	case uint16:
+		v = MakeTrusted(Uint16, strconv.AppendUint(nil, uint64(goval), 10))
+	case uint32:
+		v = MakeTrusted(Uint32, strconv.AppendUint(nil, uint64(goval), 10))
+	case float32:
+		v = MakeTrusted(Float32, strconv.AppendFloat(nil, float64(goval), 'f', -1, 64))
+	case string:
+		v = MakeTrusted(VarBinary, []byte(goval))
+	case time.Time:
+		v = MakeTrusted(Datetime, []byte(goval.Format("2006-01-02 15:04:05")))
+	case Value:
+		v = goval
+	case *BindVariable:
+		return ValueFromBytes(goval.Type, goval.Value)
+	default:
+		return v, fmt.Errorf("unexpected type %T: %v", goval, goval)
+	}
+	return v, nil
+}
+
+// BuildConverted is like BuildValue except that it tries to
+// convert a string or []byte to an integral if the target type
+// is an integral. We don't perform other implicit conversions
+// because they're unsafe.
+func BuildConverted(typ Type, goval interface{}) (v Value, err error) {
+	if IsIntegral(typ) {
+		switch goval := goval.(type) {
+		case []byte:
+			return ValueFromBytes(typ, goval)
+		case string:
+			return ValueFromBytes(typ, []byte(goval))
+		case Value:
+			if goval.IsQuoted() {
+				return ValueFromBytes(typ, goval.Raw())
+			}
+		}
+	}
+	return BuildValue(goval)
+}
+
+// ValueFromBytes builds a Value using typ and val. It ensures that val
+// matches the requested type. If type is an integral it's converted to
+// a canonical form. Otherwise, the original representation is preserved.
+func ValueFromBytes(typ Type, val []byte) (v Value, err error) {
+	switch {
+	case IsSigned(typ):
+		signed, err := strconv.ParseInt(string(val), 0, 64)
+		if err != nil {
+			return NULL, err
+		}
+		v = MakeTrusted(typ, strconv.AppendInt(nil, signed, 10))
+	case IsUnsigned(typ):
+		unsigned, err := strconv.ParseUint(string(val), 0, 64)
+		if err != nil {
+			return NULL, err
+		}
+		v = MakeTrusted(typ, strconv.AppendUint(nil, unsigned, 10))
+	case IsFloat(typ) || typ == Decimal:
+		_, err := strconv.ParseFloat(string(val), 64)
+		if err != nil {
+			return NULL, err
+		}
+		// After verification, we preserve the original representation.
+		fallthrough
+	default:
+		v = MakeTrusted(typ, val)
+	}
+	return v, nil
+}
+
+// BuildIntegral builds an integral type from a string representation.
+// The type will be Int64 or Uint64. Int64 will be preferred where possible.
+func BuildIntegral(val string) (n Value, err error) {
+	signed, err := strconv.ParseInt(val, 0, 64)
+	if err == nil {
+		return MakeTrusted(Int64, strconv.AppendInt(nil, signed, 10)), nil
+	}
+	unsigned, err := strconv.ParseUint(val, 0, 64)
+	if err != nil {
+		return Value{}, err
+	}
+	return MakeTrusted(Uint64, strconv.AppendUint(nil, unsigned, 10)), nil
+}
+
+// Type returns the type of Value.
+func (v Value) Type() Type {
+	return v.typ
+}
+
+// Raw returns the raw bytes. All types are currently implemented as []byte.
+// You should avoid using this function. If you do, you should treat the
+// bytes as read-only.
+func (v Value) Raw() []byte {
+	return v.val
+}
+
+// Len returns the length.
+func (v Value) Len() int {
+	return len(v.val)
+}
+
+// Values represents the array of Value.
+type Values []Value
+
+// Len implements the interface.
+func (vs Values) Len() int {
+	len := 0
+	for _, v := range vs {
+		len += v.Len()
+	}
+	return len
+}
+
+// String returns the raw value as a string.
+func (v Value) String() string {
+	return BytesToString(v.val)
+}
+
+// ToNative converts Value to a native go type.
+// This does not work for sqltypes.Tuple. The function
+// panics if there are inconsistencies.
+func (v Value) ToNative() interface{} {
+	var out interface{}
+	var err error
+	switch {
+	case v.typ == Null:
+		// no-op
+	case IsSigned(v.typ):
+		out, err = v.ParseInt64()
+	case IsUnsigned(v.typ):
+		out, err = v.ParseUint64()
+	case IsFloat(v.typ):
+		out, err = v.ParseFloat64()
+	default:
+		out = v.val
+	}
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// ParseInt64 will parse a Value into an int64. It does
+// not check the type.
+func (v Value) ParseInt64() (val int64, err error) {
+	return strconv.ParseInt(v.String(), 10, 64)
+}
+
+// ParseUint64 will parse a Value into a uint64. It does
+// not check the type.
+func (v Value) ParseUint64() (val uint64, err error) {
+	return strconv.ParseUint(v.String(), 10, 64)
+}
+
+// ParseFloat64 will parse a Value into an float64. It does
+// not check the type.
+func (v Value) ParseFloat64() (val float64, err error) {
+	return strconv.ParseFloat(v.String(), 64)
+}
+
+// IsNull returns true if Value is null.
+func (v Value) IsNull() bool {
+	return v.typ == Null
+}
+
+// IsIntegral returns true if Value is an integral.
+func (v Value) IsIntegral() bool {
+	return IsIntegral(v.typ)
+}
+
+// IsSigned returns true if Value is a signed integral.
+func (v Value) IsSigned() bool {
+	return IsSigned(v.typ)
+}
+
+// IsUnsigned returns true if Value is an unsigned integral.
+func (v Value) IsUnsigned() bool {
+	return IsUnsigned(v.typ)
+}
+
+// IsFloat returns true if Value is a float.
+func (v Value) IsFloat() bool {
+	return IsFloat(v.typ)
+}
+
+// IsQuoted returns true if Value must be SQL-quoted.
+func (v Value) IsQuoted() bool {
+	return IsQuoted(v.typ)
+}
+
+// IsText returns true if Value is a collatable text.
+func (v Value) IsText() bool {
+	return IsText(v.typ)
+}
+
+// IsBinary returns true if Value is binary.
+func (v Value) IsBinary() bool {
+	return IsBinary(v.typ)
+}
+
+// IsTemporal returns true if Value is time type.
+func (v Value) IsTemporal() bool {
+	return IsTemporal(v.typ)
+}
+
+// ToString returns the value as MySQL would return it as string.
+// If the value is not convertible like in the case of Expression, it returns nil.
+func (v Value) ToString() string {
+	return BytesToString(v.val)
+}

weed/server/volume_grpc_copy.go

@@ -257,7 +257,3 @@ func (vs *VolumeServer) CopyFile(req *volume_server_pb.CopyFileRequest, stream v
 
 	return nil
 }
-
-func (vs *VolumeServer) findVolumeOrEcVolumeLocation(volumeId needle.VolumeId) {
-
-}

weed/server/volume_grpc_query.go

@@ -0,0 +1,69 @@
+package weed_server
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/operation"
+	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
+	"github.com/chrislusf/seaweedfs/weed/query/json"
+	"github.com/chrislusf/seaweedfs/weed/storage/needle"
+	"github.com/tidwall/gjson"
+)
+
+func (vs *VolumeServer) Query(req *volume_server_pb.QueryRequest, stream volume_server_pb.VolumeServer_QueryServer) error {
+
+	for _, fid := range req.FromFileIds {
+
+		vid, id_cookie, err := operation.ParseFileId(fid)
+		if err != nil {
+			glog.V(0).Infof("volume query failed to parse fid %s: %v", fid, err)
+			return err
+		}
+
+		n := new(needle.Needle)
+		volumeId, _ := needle.NewVolumeId(vid)
+		n.ParsePath(id_cookie)
+
+		cookie := n.Cookie
+		if _, err := vs.store.ReadVolumeNeedle(volumeId, n); err != nil {
+			glog.V(0).Infof("volume query failed to read fid %s: %v", fid, err)
+			return err
+		}
+
+		if n.Cookie != cookie {
+			glog.V(0).Infof("volume query failed to read fid cookie %s: %v", fid, err)
+			return err
+		}
+
+		if req.InputSerialization.CsvInput != nil {
+
+		}
+
+		if req.InputSerialization.JsonInput != nil {
+
+			stripe := &volume_server_pb.QueriedStripe{
+				Records: nil,
+			}
+
+			filter := json.Query{
+				Field: req.Filter.Field,
+				Op:    req.Filter.Operand,
+				Value: req.Filter.Value,
+			}
+			gjson.ForEachLine(string(n.Data), func(line gjson.Result) bool {
+				passedFilter, values := json.QueryJson(line.Raw, req.Selections, filter)
+				if !passedFilter {
+					return true
+				}
+				stripe.Records = json.ToJson(stripe.Records, req.Selections, values)
+				return true
+			})
+			err = stream.Send(stripe)
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+
+	return nil
+}

weed/storage/volume_loading.go

@@ -59,6 +59,9 @@ func (v *Volume) load(alsoLoadIndex bool, createDatIfMissing bool, needleMapKind
 	if alreadyHasSuperBlock {
 		e = v.readSuperBlock()
 	} else {
+		if !v.SuperBlock.Initialized() {
+			return fmt.Errorf("volume %s.dat not initialized", fileName)
+		}
 		e = v.maybeWriteSuperBlock()
 	}
 	if e == nil && alsoLoadIndex {

weed/storage/volume_super_block.go

@@ -71,6 +71,10 @@ func (s *SuperBlock) Bytes() []byte {
 	return header
 }
 
+func (s *SuperBlock) Initialized() bool {
+	return s.ReplicaPlacement != nil && s.Ttl != nil
+}
+
 func (v *Volume) maybeWriteSuperBlock() error {
 
 	mMap, exists := memory_map.FileMemoryMap[v.dataFile.Name()]

weed/util/constants.go

@@ -5,5 +5,5 @@ import (
 )
 
 var (
-	VERSION = fmt.Sprintf("%s %d.%d", sizeLimit, 1, 43)
+	VERSION = fmt.Sprintf("%s %d.%d", sizeLimit, 1, 44)
 )

weed/wdclient/masterclient.go

@@ -79,10 +79,8 @@ func (mc *MasterClient) tryConnectToMaster(master string) (nextHintedLeader stri
 			return err
 		}
 
-		if mc.currentMaster == "" {
+		glog.V(1).Infof("%s Connected to %v", mc.name, master)
-			glog.V(1).Infof("%s Connected to %v", mc.name, master)
+		mc.currentMaster = master
-			mc.currentMaster = master
-		}
 
 		for {
 			volumeLocation, err := stream.Recv()