Kotlin Room错误：实体和pojos应该具有构造函数

Question

请不要将其标记为重复，我也见过其他类似的帖子，但没有帮助

我的实体：

public static void main(String[] args) throws InterruptedException {


    System.setProperty("webdriver.chrome.driver", "I:\\Selenium\\chromedriver.exe");
    WebDriver driver= new ChromeDriver();
     JavascriptExecutor js = (JavascriptExecutor) driver;
    driver.get("https://jpg2png.com");
    driver.manage().window().maximize();
    js.executeScript("window.scroll(0,100)");


    WebElement Pic=driver.findElement(By.id("pick-files"));
    String js1 = "arguments[0].style.height='auto'; arguments[0].style.visibility='visible';";

    Pic.sendKeys("D:\\University Work\\6th Semester\\IAP\\outline.jpg");

    Thread.sleep(10000);
    driver.quit();
}

我的道：

    var simulation = d3.forceSimulation()
        .force("link", d3.forceLink().id(function(d) { return d.id; }).strength(0.9))
        .force("charge", d3.forceManyBody())
        .force("center", d3.forceCenter(width / 2, height / 2))


d3.json('demo.json', function(error, graph) {
  if (error) throw error;


    drawGraph("Artifacts");


   function drawGraph(selectedValue) {
       // create groups, links and nodes
       groups = svg.append('g').attr('class', 'groups');

       link = svg.append('g')
           .attr('class', 'links')
           .selectAll('line')
           .data(graph.links)
           .enter().append('line')
           .attr('stroke-width', function (d) {
               return Math.sqrt(d.value);
           });

       node = svg.append('g')
           .attr('class', 'nodes')
           .selectAll('circle')
           .data(graph.nodes)
           .enter().append('circle')
           .attr('r', function (d) {
               if (d.type == "agent") {
                   return 10
               }
               return 5
           })
           .attr('fill', function (d) {
               if (selectedValue === "Artifacts") {
                   if (d.type == "Process") {
                       return "white"
                   } else if (d.type == "user") {
                       return "blue"
                   } else if (d.type == "File") {
                       return "green"
                   } else if (d.type == "File") {
                       return "green"
                   } else if (d.type == "agent") {
                       return color(d.group);
                   }
               } else {
                   console.log(d.threatscore);
                   if(d.threatscore>=0&&d.threatscore<3){
                       if(d.type=="agent"){
                           return color(d.group);
                       }else {
                           return "green"
                       }
                   }
                   else if(d.threatscore>=3&&d.threatscore<6){
                       return "yellow"
                   }
                   if(d.threatscore>=6&&d.threatscore<9){
                       return "red"
                   }
               }
           })
           // .attr('fill', function(d) { return color(d.group); })
           .call(d3.drag()
               .on('start', dragstarted)
               .on('drag', dragged)
               .on('end', dragended));

       var tip;
       svg.on("click", function () {
           if (tip) tip.remove();
       });
       node.on("click", function (d) {
           d3.event.stopPropagation();

           if (tip) tip.remove();

           tip = svg.append("g")
               .attr("transform", "translate(" + d.x + "," + d.y + ")");

           var rect = tip.append("rect")
               .style("fill", "white")
               .style("stroke", "steelblue");

           tip.append("text")
               .text("Name: " + d.name)
               .attr("dy", "1em")
               .attr("x", 5);

           tip.append("text")
               .text("Type: " + d.type)
               .attr("dy", "2em")
               .attr("x", 5);

           var con = graph.links
               .filter(function (d1) {
                   return d1.source.id === d.id;
               })
               .map(function (d1) {
                   return d1.target.name;
               })

           tip.append("text")
               .text("Connected to: " + con.join(","))
               .attr("dy", "3em")
               .attr("x", 5);

           tip.append("text")
               .text("Threat Score: " + d.threatscore)
               .attr("dy", "4em")
               .attr("x", 5);

           tip.append("text")
               .text("Labels: " + d.labels)
               .attr("dy", "5em")
               .attr("x", 5);

           tip.append("text")
               .text("Artifact ID: " + d.artifactid)
               .attr("dy", "6em")
               .attr("x", 5);

           tip.append("text")
               .html("More Information : <a  href='dashboard#ajax/host_details.html?'" + d.artifactid + "'> " + d.artifactid + "</a>")
               .attr("dy", "8em")
               .attr("x", 5);

           var bbox = tip.node().getBBox();
           rect.attr("width", bbox.width + 5)
               .attr("height", bbox.height + 5)
       });


       // count members of each group. Groups with less
       // than 3 member will not be considered (creating
       // a convex hull need 3 points at least)
       groupIds = d3.set(graph.nodes.map(function (n) {
           return +n.group;
       }))
           .values()
           .map(function (groupId) {
               return {
                   groupId: groupId,
                   count: graph.nodes.filter(function (n) {
                       return +n.group == groupId;
                   }).length
               };
           })
           .filter(function (group) {
               return group.count > 2;
           })
           .map(function (group) {
               return group.groupId;
           });

       paths = groups.selectAll('.path_placeholder')
           .data(groupIds, function (d) {
               return +d;
           })
           .enter()
           .append('g')
           .attr('class', 'path_placeholder')
           .append('path')
           .attr('stroke', function (d) {
               return color(d);
           })
           .attr('fill', function (d) {
               return color(d);
           })
           .attr('opacity', 0);

       paths
           .transition()
           .duration(2000)
           .attr('opacity', 1);

       // add interaction to the groups
       groups.selectAll('.path_placeholder')
           .call(d3.drag()
               .on('start', group_dragstarted)
               .on('drag', group_dragged)
               .on('end', group_dragended)
           );

       node.append('title')
           .text(function (d) {
               return d.type + " - " + d.name;
           });


       simulation
           .nodes(graph.nodes)
           .on('tick', ticked)
           .force('link')
           // .force("link", d3.forceLink().distance(function(d) {return d.distance;}).strength(0.1))
           .links(graph.links);


       function ticked() {
           link
               .attr('x1', function (d) {
                   return d.source.x;
               })
               .attr('y1', function (d) {
                   return d.source.y;
               })
               .attr('x2', function (d) {
                   return d.target.x;
               })
               .attr('y2', function (d) {
                   return d.target.y;
               });
           node
               .attr('cx', function (d) {
                   return d.x;
               })
               .attr('cy', function (d) {
                   return d.y;
               });

           updateGroups();
       }
   }
});


// select nodes of the group, retrieve its positions
// and return the convex hull of the specified points
// (3 points as minimum, otherwise returns null)
var polygonGenerator = function(groupId) {
  var node_coords = node
    .filter(function(d) { return d.group == groupId; })
    .data()
    .map(function(d) { return [d.x, d.y]; });
    console.log("Came here",node_coords)
  return d3.polygonHull(node_coords);
};



function updateGroups() {
  groupIds.forEach(function(groupId) {
    var path = paths.filter(function(d) { return d == groupId;})
      .attr('transform', 'scale(1) translate(0,0)')
      .attr('d', function(d) {
        polygon = polygonGenerator(d);
        centroid = d3.polygonCentroid(polygon);


        return valueline(
          polygon.map(function(point) {
            return [  point[0] - centroid[0], point[1] - centroid[1] ];
          })
        );
      });

    d3.select(path.node().parentNode).attr('transform', 'translate('  + centroid[0] + ',' + (centroid[1]) + ') scale(' + scaleFactor + ')');
  });
}


// drag nodes
function dragstarted(d) {
  if (!d3.event.active) simulation.alphaTarget(0.3).restart();
  d.fx = d.x;
  d.fy = d.y;
}

function dragged(d) {
  d.fx = d3.event.x;
  d.fy = d3.event.y;
}

function dragended(d) {
  if (!d3.event.active) simulation.alphaTarget(0);
  d.fx = null;
  d.fy = null;
}

// drag groups
function group_dragstarted(groupId) {
  if (!d3.event.active) simulation.alphaTarget(0.3).restart();
  d3.select(this).select('path').style('stroke-width', 3);
}

function group_dragged(groupId) {
  node
    .filter(function(d) { return d.group == groupId; })
    .each(function(d) {
      d.x += d3.event.dx;
      d.y += d3.event.dy;
    })
}

function group_dragended(groupId) {
  if (!d3.event.active) simulation.alphaTarget(0.3).restart();
  d3.select(this).select('path').style('stroke-width', 1);
} 

我正在使用@Entity(tableName = "batch_table") data class Batch( val batch_id: String? ="", val batch_name: String? ="", val user_m_id: String? ="", val user_profile_id: String? ="" ){ @PrimaryKey(autoGenerate = true) var id1: Int? = 0 constructor():this("","","","") } ，我所做的只是在@Dao interface BatchDao{ @Insert suspend fun insert(batch : MutableList<Batch>) @Query("delete from batch_table") suspend fun deleteBatchTable() @Query(" select * from batch_table ") suspend fun getAllBatches() :List<Batch> @Query("select batch_name from batch_table where batch_id = :batch_id") suspend fun getBatchName(batch_id:String) @Transaction suspend fun insertBatches(batch: MutableList<Batch>){ deleteBatchTable() insert(batch) } 中添加了第4个函数（getBatchName），但是我不确定为什么会开始出现此错误。

编译过程中的错误：

room

Answer 1

我忘了写函数的返回类型，但是抛出的错误使我想到了另一件事，所以我感到困惑。

 @Query("select batch_name from batch_table where batch_id = :batch_id")
    suspend fun getBatchName(batch_id:String) : String

。